vhdZddlmZddlmZddlmZddlZddlm Z ddl Z ddl m Z ddl mZdd lmZdd lmZdd lmZdd lmZdd lmZmZddlmZddlmZddlmZddl m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*ddl+m,Z,e,dZ-ej\Z/e j`e jbe jddZ3dZ4ddZ5ddZ6ddZ7 d ddZ8e-eedddZ9e-eedddZ:e-eedddZ;e-eedddZe-eeddd"Z?e-eeddd#Z@e-eeddd$ZAe-eeddd%ZBe-eeddd&ZCe-eeddd'ZDe-eeddd(ZEe-eeddd)ZFe-eeddd*ZGe-eeddd+ZHe-eeddd,ZIe-eeddd-ZJe-eeddd.ZKe-eeddd/ZLe-eeddd0ZMe-eeddd1ZNe-edd2ZOe-eeddd3ZPe-eeddd4ZQe-eeddd5ZRe-eeddd6ZSdd7ZTe8dejejeT8dd9ZWdd:ZXe8d;ejejeX8dd<Z[e8d=ej>dd?Z]e8dej>dd@Z_e8dej>ddAZae-eedddBZbe-eedddCZce-eedddDZde-eedddEZeddFZfe8defGddHZge-eedddIZhe8dej>ddJZje8dej>ddKZle-eedddLZme-eedddMZne-eedddNZoe8dej>ddOZqe8dPej>ddQZse8dPej>ddRZue-eedddSZv ddTZwe-eedddUZxe-eedddVZye-eedddWZze-eedddXZ{e-eedddYZ|e-eedddZZ}e-eeddd[Z~e-eeddd\Ze-eeddd]Ze-eeddd^Ze-eeddd_Ze-edd`Ze-eedddaZe-eedddbZe-eedddcZe-eeddddZe-eddeZe-eddfZe-eedddgZe-ddhZe-eddiZe-eddjZddkZe-ddlZe-ddmZeedddnZdoZe8e j& ej(>ddpZe8e j& ej,>ddqZe-eedddrZe-eedddsZe-eedddtZe-edduZdvZe-eddwZe-eddxZedyZej@dzZe-edd{Ze-dd|Ze-edd}Ze-eeddd~Ze-eedddZe-eedddZe-ddZe-ddZe-eedddZe-ddZe-eedddZe-eedddZe-edddZe-eedddZe-eddZddZe-ddZe-ddZe-eedddZe-eddZe-eddZe-eedddZe-eddZeeddZej@dZy)z" Implements ufuncs for jax.numpy. ) annotations)Callable)partialN)Any)core)dtypes)jit) custom_jvp)lax)other)Array ArrayLike)error) reductions)ufunc) check_arraylikeensure_arraylike promote_argspromote_args_inexactpromote_args_numericpromote_dtypes_inexactpromote_dtypes_numericpromote_shapes_wherecheck_no_float0s) set_modulez jax.numpy) @cVtj|tj|S)Ndtype)nparrayrr")xconsts P/opt/face_recognition/venv/lib/python3.12/site-packages/jax/_src/numpy/ufuncs.py_constant_liker(7s %v||A //cztjtt|tj||SN)r selectisposinfreal_zerosr%s r' _replace_infr1:s& HT!W%szz!}a 88r)cl|jtk(r|Stj|t |dS)Nr)r"boolr ne _lax_constr0s r'_to_boolr6=s)ggo>366!Z1-=#>>r)cPt|d}t||jdd|S)z6An internal helper function for defining unary ufuncs.Tinline)nameninnoutcallr r__name__)funcfunc_jits r' unary_ufuncrCAs% d #( xdmm JJr)c$dfd }|S)z7An internal helper function for defining binary ufuncs.c \t|d}t||jdd| S)NTr8r:) r;r<r=r>identityreduce accumulateatreduceatr?)rArBrIrJrGrHrKs r' decoratorzbinary_ufunc..decoratorLs84%H  118"6jRZb ddr))rA'Callable[[ArrayLike, ArrayLike], Array]returnr)rGrHrIrJrKrLs````` r' binary_ufuncrPGs dd r)Tr8ctd|}tjtj|tj r t dtjtd|S)aCompute the element-wise absolute values of the real-valued input. JAX implementation of :obj:`numpy.fabs`. Args: x: input array or scalar. Must not have a complex dtype. Returns: An array with same shape as ``x`` and dtype float, containing the element-wise absolute values. See also: - :func:`jax.numpy.absolute`: Computes the absolute values of the input including complex dtypes. - :func:`jax.numpy.abs`: Computes the absolute values of the input including complex dtypes. Examples: For integer inputs: >>> x = jnp.array([-5, -9, 1, 10, 15]) >>> jnp.fabs(x) Array([ 5., 9., 1., 10., 15.], dtype=float32) For float type inputs: >>> x1 = jnp.array([-1.342, 5.649, 3.927]) >>> jnp.fabs(x1) Array([1.342, 5.649, 3.927], dtype=float32) For boolean inputs: >>> x2 = jnp.array([True, False]) >>> jnp.fabs(x2) Array([1., 0.], dtype=float32) fabsz,ufunc 'fabs' does not support complex dtypes) rr issubdtyper"r#complexfloating TypeErrorr absrr0s r'rRrRSsRNvq!! v||A(:(:; B CC &vq1 22r)c:tjtd|S)"Alias of :func:`jax.numpy.invert`.bitwise_invertr bitwise_notrr0s r'rYrYs ,'7; <>> x = jnp.arange(5, dtype='uint8') >>> print(x) [0 1 2 3 4] >>> print(jnp.invert(x)) [255 254 253 252 251] This function implements the unary ``~`` operator for JAX arrays: >>> print(~x) [255 254 253 252 251] :func:`invert` operates bitwise on the input, and so the meaning of its output may be more clear by showing the bitwise representation: >>> with jnp.printoptions(formatter={'int': lambda x: format(x, '#010b')}): ... print(f"{x = }") ... print(f"{~x = }") x = Array([0b00000000, 0b00000001, 0b00000010, 0b00000011, 0b00000100], dtype=uint8) ~x = Array([0b11111111, 0b11111110, 0b11111101, 0b11111100, 0b11111011], dtype=uint8) For boolean inputs, :func:`invert` is equivalent to :func:`logical_not`: >>> x = jnp.array([True, False, True, True, False]) >>> jnp.invert(x) Array([False, True, False, False, True], dtype=bool) invertrZr0s r'r^r^sZ ,x3 44r)c:tjtd|S)a|Return element-wise negative values of the input. JAX implementation of :obj:`numpy.negative`. Args: x: input array or scalar. Returns: An array with same shape and dtype as ``x`` containing ``-x``. See also: - :func:`jax.numpy.positive`: Returns element-wise positive values of the input. - :func:`jax.numpy.sign`: Returns element-wise indication of sign of the input. Note: ``jnp.negative``, when applied over ``unsigned integer``, produces the result of their two's complement negation, which typically results in unexpected large positive values due to integer underflow. Examples: For real-valued inputs: >>> x = jnp.array([0., -3., 7]) >>> jnp.negative(x) Array([-0., 3., -7.], dtype=float32) For complex inputs: >>> x1 = jnp.array([1-2j, -3+4j, 5-6j]) >>> jnp.negative(x1) Array([-1.+2.j, 3.-4.j, -5.+6.j], dtype=complex64) For unit32: >>> x2 = jnp.array([5, 0, -7]).astype(jnp.uint32) >>> x2 Array([ 5, 0, 4294967289], dtype=uint32) >>> jnp.negative(x2) Array([4294967291, 0, 7], dtype=uint32) negative)r negrr0s r'r`r`sT ,z1- ..r)c:tjtd|S)aReturn element-wise positive values of the input. JAX implementation of :obj:`numpy.positive`. Args: x: input array or scalar Returns: An array of same shape and dtype as ``x`` containing ``+x``. Note: ``jnp.positive`` is equivalent to ``x.copy()`` and is defined only for the types that support arithmetic operations. See also: - :func:`jax.numpy.negative`: Returns element-wise negative values of the input. - :func:`jax.numpy.sign`: Returns element-wise indication of sign of the input. Examples: For real-valued inputs: >>> x = jnp.array([-5, 4, 7., -9.5]) >>> jnp.positive(x) Array([-5. , 4. , 7. , -9.5], dtype=float32) >>> x.copy() Array([-5. , 4. , 7. , -9.5], dtype=float32) For complex inputs: >>> x1 = jnp.array([1-2j, -3+4j, 5-6j]) >>> jnp.positive(x1) Array([ 1.-2.j, -3.+4.j, 5.-6.j], dtype=complex64) >>> x1.copy() Array([ 1.-2.j, -3.+4.j, 5.-6.j], dtype=complex64) For uint32: >>> x2 = jnp.array([6, 0, -4]).astype(jnp.uint32) >>> x2 Array([ 6, 0, 4294967292], dtype=uint32) >>> jnp.positive(x2) Array([ 6, 0, 4294967292], dtype=uint32) positive)r asarrayrr0s r'rcrcs\ l:q1 22r)c:tjtd|S)alReturn an element-wise indication of sign of the input. JAX implementation of :obj:`numpy.sign`. The sign of ``x`` for real-valued input is: .. math:: \mathrm{sign}(x) = \begin{cases} 1, & x > 0\\ 0, & x = 0\\ -1, & x < 0 \end{cases} For complex valued input, ``jnp.sign`` returns a unit vector representing the phase. For generalized case, the sign of ``x`` is given by: .. math:: \mathrm{sign}(x) = \begin{cases} \frac{x}{abs(x)}, & x \ne 0\\ 0, & x = 0 \end{cases} Args: x: input array or scalar. Returns: An array with same shape and dtype as ``x`` containing the sign indication. See also: - :func:`jax.numpy.positive`: Returns element-wise positive values of the input. - :func:`jax.numpy.negative`: Returns element-wise negative values of the input. Examples: For Real-valued inputs: >>> x = jnp.array([0., -3., 7.]) >>> jnp.sign(x) Array([ 0., -1., 1.], dtype=float32) For complex-inputs: >>> x1 = jnp.array([1, 3+4j, 5j]) >>> jnp.sign(x1) Array([1. +0.j , 0.6+0.8j, 0. +1.j ], dtype=complex64) sign)r rfrr0s r'rfrfs` <* ++r)ctd|}tjtj|dr|St j t d|S)aRound input to the nearest integer downwards. JAX implementation of :obj:`numpy.floor`. Args: x: input array or scalar. Must not have complex dtype. Returns: An array with same shape and dtype as ``x`` containing the values rounded to the nearest integer that is less than or equal to the value itself. See also: - :func:`jax.numpy.fix`: Rounds the input to the nearest integer towards zero. - :func:`jax.numpy.trunc`: Rounds the input to the nearest integer towards zero. - :func:`jax.numpy.ceil`: Rounds the input up to the nearest integer. Examples: >>> key = jax.random.key(42) >>> x = jax.random.uniform(key, (3, 3), minval=-5, maxval=5) >>> with jnp.printoptions(precision=2, suppress=True): ... print(x) [[-0.11 1.8 1.16] [ 0.61 -0.49 0.86] [-4.25 2.75 1.99]] >>> jnp.floor(x) Array([[-1., 1., 1.], [ 0., -1., 0.], [-5., 2., 1.]], dtype=float32) floorintegralr3)rrisdtyper"r rhrr0s r'rhrhOsDBw"! ^^FLLO%9: H (!4 55r)ctd|}tjtj|drt j |St j td|S)aRound input to the nearest integer upwards. JAX implementation of :obj:`numpy.ceil`. Args: x: input array or scalar. Must not have complex dtype. Returns: An array with same shape and dtype as ``x`` containing the values rounded to the nearest integer that is greater than or equal to the value itself. See also: - :func:`jax.numpy.fix`: Rounds the input to the nearest integer towards zero. - :func:`jax.numpy.trunc`: Rounds the input to the nearest integer towards zero. - :func:`jax.numpy.floor`: Rounds the input down to the nearest integer. Examples: >>> key = jax.random.key(1) >>> x = jax.random.uniform(key, (3, 3), minval=-5, maxval=5) >>> with jnp.printoptions(precision=2, suppress=True): ... print(x) [[-0.61 0.34 -0.54] [-0.62 3.97 0.59] [ 4.84 3.42 -1.14]] >>> jnp.ceil(x) Array([[-0., 1., -0.], [-0., 4., 1.], [ 5., 4., -1.]], dtype=float32) ceilri)rrrkr"r rdrmrr0s r'rmrmvsMBvq!! ^^FLLO%9: ;;q> '2 33r)c:tjtd|S)aVCalculate element-wise exponential of the input. JAX implementation of :obj:`numpy.exp`. Args: x: input array or scalar Returns: An array containing the exponential of each element in ``x``, promotes to inexact dtype. See also: - :func:`jax.numpy.log`: Calculates element-wise logarithm of the input. - :func:`jax.numpy.expm1`: Calculates :math:`e^x-1` of each element of the input. - :func:`jax.numpy.exp2`: Calculates base-2 exponential of each element of the input. Examples: ``jnp.exp`` follows the properties of exponential such as :math:`e^{(a+b)} = e^a * e^b`. >>> x1 = jnp.array([2, 4, 3, 1]) >>> x2 = jnp.array([1, 3, 2, 3]) >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.exp(x1+x2)) [ 20.09 1096.63 148.41 54.6 ] >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.exp(x1)*jnp.exp(x2)) [ 20.09 1096.63 148.41 54.6 ] This property holds for complex input also: >>> jnp.allclose(jnp.exp(3-4j), jnp.exp(3)*jnp.exp(-4j)) Array(True, dtype=bool) exp)r rorr0s r'rorosN &ua0 11r)chtjtd|}tj||S)a4Calculate element-wise natural logarithm of the input. JAX implementation of :obj:`numpy.log`. Args: x: input array or scalar. Returns: An array containing the logarithm of each element in ``x``, promotes to inexact dtype. See also: - :func:`jax.numpy.exp`: Calculates element-wise exponential of the input. - :func:`jax.numpy.log2`: Calculates base-2 logarithm of each element of input. - :func:`jax.numpy.log1p`: Calculates element-wise logarithm of one plus input. Examples: ``jnp.log`` and ``jnp.exp`` are inverse functions of each other. Applying ``jnp.log`` on the result of ``jnp.exp(x)`` yields the original input ``x``. >>> x = jnp.array([2, 3, 4, 5]) >>> jnp.log(jnp.exp(x)) Array([2., 3., 4., 5.], dtype=float32) Using ``jnp.log`` we can demonstrate well-known properties of logarithms, such as :math:`log(a*b) = log(a)+log(b)`. >>> x1 = jnp.array([2, 1, 3, 1]) >>> x2 = jnp.array([1, 3, 2, 4]) >>> jnp.allclose(jnp.log(x1*x2), jnp.log(x1)+jnp.log(x2)) Array(True, dtype=bool) log)r rqr jnp_error_set_error_if_nanr%outs r'rqrqs.F %eQ/0# c" *r)c:tjtd|S)aCalculate ``exp(x)-1`` of each element of the input. JAX implementation of :obj:`numpy.expm1`. Args: x: input array or scalar. Returns: An array containing ``exp(x)-1`` of each element in ``x``, promotes to inexact dtype. Note: ``jnp.expm1`` has much higher precision than the naive computation of ``exp(x)-1`` for small values of ``x``. See also: - :func:`jax.numpy.log1p`: Calculates element-wise logarithm of one plus input. - :func:`jax.numpy.exp`: Calculates element-wise exponential of the input. - :func:`jax.numpy.exp2`: Calculates base-2 exponential of each element of the input. Examples: >>> x = jnp.array([2, -4, 3, -1]) >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.expm1(x)) [ 6.39 -0.98 19.09 -0.63] >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.exp(x)-1) [ 6.39 -0.98 19.09 -0.63] For values very close to 0, ``jnp.expm1(x)`` is much more accurate than ``jnp.exp(x)-1``: >>> x1 = jnp.array([1e-4, 1e-6, 2e-10]) >>> jnp.expm1(x1) Array([1.0000500e-04, 1.0000005e-06, 2.0000000e-10], dtype=float32) >>> jnp.exp(x1)-1 Array([1.00016594e-04, 9.53674316e-07, 0.00000000e+00], dtype=float32) expm1)r rwrr0s r'rwrwsT (!4 55r)chtjtd|}tj||S)aCalculates element-wise logarithm of one plus input, ``log(x+1)``. JAX implementation of :obj:`numpy.log1p`. Args: x: input array or scalar. Returns: An array containing the logarithm of one plus of each element in ``x``, promotes to inexact dtype. Note: ``jnp.log1p`` is more accurate than when using the naive computation of ``log(x+1)`` for small values of ``x``. See also: - :func:`jax.numpy.expm1`: Calculates :math:`e^x-1` of each element of the input. - :func:`jax.numpy.log2`: Calculates base-2 logarithm of each element of input. - :func:`jax.numpy.log`: Calculates element-wise logarithm of the input. Examples: >>> x = jnp.array([2, 5, 9, 4]) >>> jnp.allclose(jnp.log1p(x), jnp.log(x+1)) Array(True, dtype=bool) For values very close to 0, ``jnp.log1p(x)`` is more accurate than ``jnp.log(x+1)``: >>> x1 = jnp.array([1e-4, 1e-6, 2e-10]) >>> jnp.expm1(jnp.log1p(x1)) # doctest: +SKIP Array([1.00000005e-04, 9.99999997e-07, 2.00000003e-10], dtype=float32) >>> jnp.expm1(jnp.log(x1+1)) # doctest: +SKIP Array([1.000166e-04, 9.536743e-07, 0.000000e+00], dtype=float32) log1p)r ryrrrrsrts r'ryrys.L '34# c" *r)chtjtd|}tj||S)aCompute a trigonometric sine of each element of input. JAX implementation of :obj:`numpy.sin`. Args: x: array or scalar. Angle in radians. Returns: An array containing the sine of each element in ``x``, promotes to inexact dtype. See also: - :func:`jax.numpy.cos`: Computes a trigonometric cosine of each element of input. - :func:`jax.numpy.tan`: Computes a trigonometric tangent of each element of input. - :func:`jax.numpy.arcsin` and :func:`jax.numpy.asin`: Computes the inverse of trigonometric sine of each element of input. Examples: >>> pi = jnp.pi >>> x = jnp.array([pi/4, pi/2, 3*pi/4, pi]) >>> with jnp.printoptions(precision=3, suppress=True): ... print(jnp.sin(x)) [ 0.707 1. 0.707 -0. ] sin)r r{rrrrsrts r'r{r{Gs-: %eQ/0# c" *r)chtjtd|}tj||S)aCompute a trigonometric cosine of each element of input. JAX implementation of :obj:`numpy.cos`. Args: x: scalar or array. Angle in radians. Returns: An array containing the cosine of each element in ``x``, promotes to inexact dtype. See also: - :func:`jax.numpy.sin`: Computes a trigonometric sine of each element of input. - :func:`jax.numpy.tan`: Computes a trigonometric tangent of each element of input. - :func:`jax.numpy.arccos` and :func:`jax.numpy.acos`: Computes the inverse of trigonometric cosine of each element of input. Examples: >>> pi = jnp.pi >>> x = jnp.array([pi/4, pi/2, 3*pi/4, 5*pi/6]) >>> with jnp.printoptions(precision=3, suppress=True): ... print(jnp.cos(x)) [ 0.707 -0. -0.707 -0.866] cos)r r}rrrrsrts r'r}r}i-8 %eQ/0# c" *r)chtjtd|}tj||S)a#Compute a trigonometric tangent of each element of input. JAX implementation of :obj:`numpy.tan`. Args: x: scalar or array. Angle in radians. Returns: An array containing the tangent of each element in ``x``, promotes to inexact dtype. See also: - :func:`jax.numpy.sin`: Computes a trigonometric sine of each element of input. - :func:`jax.numpy.cos`: Computes a trigonometric cosine of each element of input. - :func:`jax.numpy.arctan` and :func:`jax.numpy.atan`: Computes the inverse of trigonometric tangent of each element of input. Examples: >>> pi = jnp.pi >>> x = jnp.array([0, pi/6, pi/4, 3*pi/4, 5*pi/6]) >>> with jnp.printoptions(precision=3, suppress=True): ... print(jnp.tan(x)) [ 0. 0.577 1. -1. -0.577] tan)r rrrrrsrts r'rrr~r)chtjtd|}tj||S)a'Compute element-wise inverse of trigonometric sine of input. JAX implementation of :obj:`numpy.arcsin`. Args: x: input array or scalar. Returns: An array containing the inverse trigonometric sine of each element of ``x`` in radians in the range ``[-pi/2, pi/2]``, promoting to inexact dtype. Note: - ``jnp.arcsin`` returns ``nan`` when ``x`` is real-valued and not in the closed interval ``[-1, 1]``. - ``jnp.arcsin`` follows the branch cut convention of :obj:`numpy.arcsin` for complex inputs. See also: - :func:`jax.numpy.sin`: Computes a trigonometric sine of each element of input. - :func:`jax.numpy.arccos` and :func:`jax.numpy.acos`: Computes the inverse of trigonometric cosine of each element of input. - :func:`jax.numpy.arctan` and :func:`jax.numpy.atan`: Computes the inverse of trigonometric tangent of each element of input. Examples: >>> x = jnp.array([-2, -1, -0.5, 0, 0.5, 1, 2]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arcsin(x) Array([ nan, -1.571, -0.524, 0. , 0.524, 1.571, nan], dtype=float32) For complex-valued inputs: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arcsin(3+4j) Array(0.634+2.306j, dtype=complex64, weak_type=True) arcsin)r asinrrrrsrts r'rrs.N &x34# c" *r)chtjtd|}tj||S)aCompute element-wise inverse of trigonometric cosine of input. JAX implementation of :obj:`numpy.arccos`. Args: x: input array or scalar. Returns: An array containing the inverse trigonometric cosine of each element of ``x`` in radians in the range ``[0, pi]``, promoting to inexact dtype. Note: - ``jnp.arccos`` returns ``nan`` when ``x`` is real-valued and not in the closed interval ``[-1, 1]``. - ``jnp.arccos`` follows the branch cut convention of :obj:`numpy.arccos` for complex inputs. See also: - :func:`jax.numpy.cos`: Computes a trigonometric cosine of each element of input. - :func:`jax.numpy.arcsin` and :func:`jax.numpy.asin`: Computes the inverse of trigonometric sine of each element of input. - :func:`jax.numpy.arctan` and :func:`jax.numpy.atan`: Computes the inverse of trigonometric tangent of each element of input. Examples: >>> x = jnp.array([-2, -1, -0.5, 0, 0.5, 1, 2]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arccos(x) Array([ nan, 3.142, 2.094, 1.571, 1.047, 0. , nan], dtype=float32) For complex inputs: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arccos(4-1j) Array(0.252+2.097j, dtype=complex64, weak_type=True) arccos)r acosrrrrsrts r'rrs.P &x34# c" *r)c:tjtd|S)aCompute element-wise inverse of trigonometric tangent of input. JAX implement of :obj:`numpy.arctan`. Args: x: input array or scalar. Returns: An array containing the inverse trigonometric tangent of each element ``x`` in radians in the range ``[-pi/2, pi/2]``, promoting to inexact dtype. Note: ``jnp.arctan`` follows the branch cut convention of :obj:`numpy.arctan` for complex inputs. See also: - :func:`jax.numpy.tan`: Computes a trigonometric tangent of each element of input. - :func:`jax.numpy.arcsin` and :func:`jax.numpy.asin`: Computes the inverse of trigonometric sine of each element of input. - :func:`jax.numpy.arccos` and :func:`jax.numpy.atan`: Computes the inverse of trigonometric cosine of each element of input. Examples: >>> x = jnp.array([-jnp.inf, -20, -1, 0, 1, 20, jnp.inf]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arctan(x) Array([-1.571, -1.521, -0.785, 0. , 0.785, 1.521, 1.571], dtype=float32) For complex-valued inputs: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arctan(2+7j) Array(1.532+0.133j, dtype=complex64, weak_type=True) arctan)r atanrr0s r'rrsL '!4 55r)c:tjtd|S)aCalculate element-wise hyperbolic sine of input. JAX implementation of :obj:`numpy.sinh`. The hyperbolic sine is defined by: .. math:: sinh(x) = \frac{e^x - e^{-x}}{2} Args: x: input array or scalar. Returns: An array containing the hyperbolic sine of each element of ``x``, promoting to inexact dtype. Note: ``jnp.sinh`` is equivalent to computing ``-1j * jnp.sin(1j * x)``. See also: - :func:`jax.numpy.cosh`: Computes the element-wise hyperbolic cosine of the input. - :func:`jax.numpy.tanh`: Computes the element-wise hyperbolic tangent of the input. - :func:`jax.numpy.arcsinh`: Computes the element-wise inverse of hyperbolic sine of the input. Examples: >>> x = jnp.array([[-2, 3, 5], ... [0, -1, 4]]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.sinh(x) Array([[-3.627, 10.018, 74.203], [ 0. , -1.175, 27.29 ]], dtype=float32) >>> with jnp.printoptions(precision=3, suppress=True): ... -1j * jnp.sin(1j * x) Array([[-3.627+0.j, 10.018-0.j, 74.203-0.j], [ 0. -0.j, -1.175+0.j, 27.29 -0.j]], dtype=complex64, weak_type=True) For complex-valued input: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.sinh(3-2j) Array(-4.169-9.154j, dtype=complex64, weak_type=True) >>> with jnp.printoptions(precision=3, suppress=True): ... -1j * jnp.sin(1j * (3-2j)) Array(-4.169-9.154j, dtype=complex64, weak_type=True) sinh)r rrr0s r'rr-sh '2 33r)c:tjtd|S)aCalculate element-wise hyperbolic cosine of input. JAX implementation of :obj:`numpy.cosh`. The hyperbolic cosine is defined by: .. math:: cosh(x) = \frac{e^x + e^{-x}}{2} Args: x: input array or scalar. Returns: An array containing the hyperbolic cosine of each element of ``x``, promoting to inexact dtype. Note: ``jnp.cosh`` is equivalent to computing ``jnp.cos(1j * x)``. See also: - :func:`jax.numpy.sinh`: Computes the element-wise hyperbolic sine of the input. - :func:`jax.numpy.tanh`: Computes the element-wise hyperbolic tangent of the input. - :func:`jax.numpy.arccosh`: Computes the element-wise inverse of hyperbolic cosine of the input. Examples: >>> x = jnp.array([[3, -1, 0], ... [4, 7, -5]]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.cosh(x) Array([[ 10.068, 1.543, 1. ], [ 27.308, 548.317, 74.21 ]], dtype=float32) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.cos(1j * x) Array([[ 10.068+0.j, 1.543+0.j, 1. +0.j], [ 27.308+0.j, 548.317+0.j, 74.21 +0.j]], dtype=complex64, weak_type=True) For complex-valued input: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.cosh(5+1j) Array(40.096+62.44j, dtype=complex64, weak_type=True) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.cos(1j * (5+1j)) Array(40.096+62.44j, dtype=complex64, weak_type=True) cosh)r rrr0s r'rrdf '2 33r)c:tjtd|S)agCalculate element-wise inverse of hyperbolic sine of input. JAX implementation of :obj:`numpy.arcsinh`. The inverse of hyperbolic sine is defined by: .. math:: arcsinh(x) = \ln(x + \sqrt{1 + x^2}) Args: x: input array or scalar. Returns: An array of same shape as ``x`` containing the inverse of hyperbolic sine of each element of ``x``, promoting to inexact dtype. Note: - ``jnp.arcsinh`` returns ``nan`` for values outside the range ``(-inf, inf)``. - ``jnp.arcsinh`` follows the branch cut convention of :obj:`numpy.arcsinh` for complex inputs. See also: - :func:`jax.numpy.sinh`: Computes the element-wise hyperbolic sine of the input. - :func:`jax.numpy.arccosh`: Computes the element-wise inverse of hyperbolic cosine of the input. - :func:`jax.numpy.arctanh`: Computes the element-wise inverse of hyperbolic tangent of the input. Examples: >>> x = jnp.array([[-2, 3, 1], ... [4, 9, -5]]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arcsinh(x) Array([[-1.444, 1.818, 0.881], [ 2.095, 2.893, -2.312]], dtype=float32) For complex-valued inputs: >>> x1 = jnp.array([4-3j, 2j]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arcsinh(x1) Array([2.306-0.634j, 1.317+1.571j], dtype=complex64) arcsinh)r asinhrr0s r'rrs^ (A6 77r)ctjtd|}tj|t j |jtjr,tt|dktj||}|S)aCalculate element-wise inverse of hyperbolic cosine of input. JAX implementation of :obj:`numpy.arccosh`. The inverse of hyperbolic cosine is defined by: .. math:: arccosh(x) = \ln(x + \sqrt{x^2 - 1}) Args: x: input array or scalar. Returns: An array of same shape as ``x`` containing the inverse of hyperbolic cosine of each element of ``x``, promoting to inexact dtype. Note: - ``jnp.arccosh`` returns ``nan`` for real-values in the range ``[-inf, 1)``. - ``jnp.arccosh`` follows the branch cut convention of :obj:`numpy.arccosh` for complex inputs. See also: - :func:`jax.numpy.cosh`: Computes the element-wise hyperbolic cosine of the input. - :func:`jax.numpy.arcsinh`: Computes the element-wise inverse of hyperbolic sine of the input. - :func:`jax.numpy.arctanh`: Computes the element-wise inverse of hyperbolic tangent of the input. Examples: >>> x = jnp.array([[1, 3, -4], ... [-5, 2, 7]]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arccosh(x) Array([[0. , 1.763, nan], [ nan, 1.317, 2.634]], dtype=float32) For complex-valued input: >>> x1 = jnp.array([-jnp.inf+0j, 1+2j, -5+0j]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arccosh(x1) Array([ inf+3.142j, 1.529+1.144j, 2.292+3.142j], dtype=complex64) arccoshr) r acoshrrrrsrrSr"r#rTrr.ra)r%results r'rrsgd 99*9a8 9& f% v||R%7%78 DL1$cggfov >F -r)c:tjtd|S)a'Calculate element-wise hyperbolic tangent of input. JAX implementation of :obj:`numpy.tanh`. The hyperbolic tangent is defined by: .. math:: tanh(x) = \frac{sinh(x)}{cosh(x)} = \frac{e^x - e^{-x}}{e^x + e^{-x}} Args: x: input array or scalar. Returns: An array containing the hyperbolic tangent of each element of ``x``, promoting to inexact dtype. Note: ``jnp.tanh`` is equivalent to computing ``-1j * jnp.tan(1j * x)``. See also: - :func:`jax.numpy.sinh`: Computes the element-wise hyperbolic sine of the input. - :func:`jax.numpy.cosh`: Computes the element-wise hyperbolic cosine of the input. - :func:`jax.numpy.arctanh`: Computes the element-wise inverse of hyperbolic tangent of the input. Examples: >>> x = jnp.array([[-1, 0, 1], ... [3, -2, 5]]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.tanh(x) Array([[-0.762, 0. , 0.762], [ 0.995, -0.964, 1. ]], dtype=float32) >>> with jnp.printoptions(precision=3, suppress=True): ... -1j * jnp.tan(1j * x) Array([[-0.762+0.j, 0. -0.j, 0.762-0.j], [ 0.995-0.j, -0.964+0.j, 1. -0.j]], dtype=complex64, weak_type=True) For complex-valued input: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.tanh(2-5j) Array(1.031+0.021j, dtype=complex64, weak_type=True) >>> with jnp.printoptions(precision=3, suppress=True): ... -1j * jnp.tan(1j * (2-5j)) Array(1.031+0.021j, dtype=complex64, weak_type=True) tanh)r rrr0s r'rrrr)chtjtd|}tj||S)aCalculate element-wise inverse of hyperbolic tangent of input. JAX implementation of :obj:`numpy.arctanh`. The inverse of hyperbolic tangent is defined by: .. math:: arctanh(x) = \frac{1}{2} [\ln(1 + x) - \ln(1 - x)] Args: x: input array or scalar. Returns: An array of same shape as ``x`` containing the inverse of hyperbolic tangent of each element of ``x``, promoting to inexact dtype. Note: - ``jnp.arctanh`` returns ``nan`` for real-values outside the range ``[-1, 1]``. - ``jnp.arctanh`` follows the branch cut convention of :obj:`numpy.arctanh` for complex inputs. See also: - :func:`jax.numpy.tanh`: Computes the element-wise hyperbolic tangent of the input. - :func:`jax.numpy.arcsinh`: Computes the element-wise inverse of hyperbolic sine of the input. - :func:`jax.numpy.arccosh`: Computes the element-wise inverse of hyperbolic cosine of the input. Examples: >>> x = jnp.array([-2, -1, -0.5, 0, 0.5, 1, 2]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arctanh(x) Array([ nan, -inf, -0.549, 0. , 0.549, inf, nan], dtype=float32) For complex-valued input: >>> x1 = jnp.array([-2+0j, 3+0j, 4-1j]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.arctanh(x1) Array([-0.549+1.571j, 0.347+1.571j, 0.239-1.509j], dtype=complex64) arctanh)r atanhrrrrsrts r'rr;s.\ ' 156# c" *r)chtjtd|}tj||S)asCalculates element-wise non-negative square root of the input array. JAX implementation of :obj:`numpy.sqrt`. Args: x: input array or scalar. Returns: An array containing the non-negative square root of the elements of ``x``. Note: - For real-valued negative inputs, ``jnp.sqrt`` produces a ``nan`` output. - For complex-valued negative inputs, ``jnp.sqrt`` produces a ``complex`` output. See also: - :func:`jax.numpy.square`: Calculates the element-wise square of the input. - :func:`jax.numpy.power`: Calculates the element-wise base ``x1`` exponential of ``x2``. Examples: >>> x = jnp.array([-8-6j, 1j, 4]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.sqrt(x) Array([1. -3.j , 0.707+0.707j, 2. +0.j ], dtype=complex64) >>> jnp.sqrt(-1) Array(nan, dtype=float32, weak_type=True) sqrt)r rrrrrsrts r'rrns-< &vq12# c" *r)c:tjtd|S)aCalculates element-wise cube root of the input array. JAX implementation of :obj:`numpy.cbrt`. Args: x: input array or scalar. ``complex`` dtypes are not supported. Returns: An array containing the cube root of the elements of ``x``. See also: - :func:`jax.numpy.sqrt`: Calculates the element-wise non-negative square root of the input. - :func:`jax.numpy.square`: Calculates the element-wise square of the input. Examples: >>> x = jnp.array([[216, 125, 64], ... [-27, -8, -1]]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.cbrt(x) Array([[ 6., 5., 4.], [-3., -2., -1.]], dtype=float32) cbrt)r rrr0s r'rrs4 '2 33r)c:|jtk(rk|jd}tj|tjd}|j |j |jtS|j |j |S)zImplementation of jnp.add.at.int32)r"r3astyper convert_element_typerJaddaindicesbs r'_add_atrsuWW_ A   D)009A 44=  Q  & &t ,, g  1 r))rGrHrIrJctd||\}}|jtk(rtj||Stj ||}t j||S)aAdd two arrays element-wise. JAX implementation of :obj:`numpy.add`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. This function provides the implementation of the ``+`` operator for JAX arrays. Args: x, y: arrays to add. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise addition. Examples: Calling ``add`` explicitly: >>> x = jnp.arange(4) >>> jnp.add(x, 10) Array([10, 11, 12, 13], dtype=int32) Calling ``add`` via the ``+`` operator: >>> x + 10 Array([10, 11, 12, 13], dtype=int32) r)rr"r3r bitwise_orrrrrsr%yrus r'rrsT6 eQ "$!QWW_ >>!Q  1 # c" *r)c:|jtk(rk|jd}tj|tjd}|j |j |jtS|j |j |S)z"Implementation of jnp.multiply.at.r)r"r3rr rrJmulrs r' _multiply_atrsuWW_ A   D)009A 44=  Q  & &t ,, 44=  Q r)r:ctd||\}}|jtk7rtj||Stj ||S)aMultiply two arrays element-wise. JAX implementation of :obj:`numpy.multiply`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. This function provides the implementation of the ``*`` operator for JAX arrays. Args: x, y: arrays to multiply. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise multiplication. Examples: Calling ``multiply`` explicitly: >>> x = jnp.arange(4) >>> jnp.multiply(x, 10) Array([ 0, 10, 20, 30], dtype=int32) Calling ``multiply`` via the ``*`` operator: >>> x * 10 Array([ 0, 10, 20, 30], dtype=int32) multiply)rr"r3r r bitwise_andr%rs r'rrs@6 j!Q '$!Q''T/ADsq!/DDr))rGrHc<tjtd||S)aCompute the bitwise AND operation elementwise. JAX implementation of :obj:`numpy.bitwise_and`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. This function provides the implementation of the ``&`` operator for JAX arrays. Args: x, y: integer or boolean arrays. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise bitwise AND. Examples: Calling ``bitwise_and`` explicitly: >>> x = jnp.arange(4) >>> jnp.bitwise_and(x, 1) Array([0, 1, 0, 1], dtype=int32) Calling ``bitwise_and`` via the ``&`` operator: >>> x & 1 Array([0, 1, 0, 1], dtype=int32) r)r rrrs r'rr6 ,}a; <>> x = jnp.arange(4) >>> jnp.bitwise_or(x, 1) Array([1, 1, 3, 3], dtype=int32) Calling ``bitwise_or`` via the ``|`` operator: >>> x | 1 Array([1, 1, 3, 3], dtype=int32) r)r rrrs r'rr!s6 lAq9 ::r)c<tjtd||S)aCompute the bitwise XOR operation elementwise. JAX implementation of :obj:`numpy.bitwise_xor`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. This function provides the implementation of the ``^`` operator for JAX arrays. Args: x, y: integer or boolean arrays. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise bitwise XOR. Examples: Calling ``bitwise_xor`` explicitly: >>> x = jnp.arange(4) >>> jnp.bitwise_xor(x, 1) Array([1, 0, 3, 2], dtype=int32) Calling ``bitwise_xor`` via the ``^`` operator: >>> x ^ 1 Array([1, 0, 3, 2], dtype=int32) bitwise_xor)r rrrs r'rr?rr)c<tjtd||S)aUShift bits of ``x`` to left by the amount specified in ``y``, element-wise. JAX implementation of :obj:`numpy.left_shift`. Args: x: Input array, must be integer-typed. y: The amount of bits to shift each element in ``x`` to the left, only accepts integer subtypes. ``x`` and ``y`` must either have same shape or be broadcast compatible. Returns: An array containing the left shifted elements of ``x`` by the amount specified in ``y``, with the same shape as the broadcasted shape of ``x`` and ``y``. Note: Left shifting ``x`` by ``y`` is equivalent to ``x * (2**y)`` within the bounds of the dtypes involved. See also: - :func:`jax.numpy.right_shift`: and :func:`jax.numpy.bitwise_right_shift`: Shifts the bits of ``x1`` to right by the amount specified in ``x2``, element-wise. - :func:`jax.numpy.bitwise_left_shift`: Alias of :func:`jax.left_shift`. Examples: >>> def print_binary(x): ... return [bin(int(val)) for val in x] >>> x1 = jnp.arange(5) >>> x1 Array([0, 1, 2, 3, 4], dtype=int32) >>> print_binary(x1) ['0b0', '0b1', '0b10', '0b11', '0b100'] >>> x2 = 1 >>> result = jnp.left_shift(x1, x2) >>> result Array([0, 2, 4, 6, 8], dtype=int32) >>> print_binary(result) ['0b0', '0b10', '0b100', '0b110', '0b1000'] >>> x3 = 4 >>> print_binary([x3]) ['0b100'] >>> x4 = jnp.array([1, 2, 3, 4]) >>> result1 = jnp.left_shift(x3, x4) >>> result1 Array([ 8, 16, 32, 64], dtype=int32) >>> print_binary(result1) ['0b1000', '0b10000', '0b100000', '0b1000000'] left_shiftr shift_leftrrs r'rr]sj -lAqA BBr)c<tjtd||S)z&Alias of :func:`jax.numpy.left_shift`.bitwise_left_shiftrrs r'rrs -.BAqI JJr)c<tjtd||S)a*Returns element-wise truth value of ``x == y``. JAX implementation of :obj:`numpy.equal`. This function provides the implementation of the ``==`` operator for JAX arrays. Args: x: input array or scalar. y: input array or scalar. ``x`` and ``y`` should either have same shape or be broadcast compatible. Returns: A boolean array containing ``True`` where the elements of ``x == y`` and ``False`` otherwise. See also: - :func:`jax.numpy.not_equal`: Returns element-wise truth value of ``x != y``. - :func:`jax.numpy.greater_equal`: Returns element-wise truth value of ``x >= y``. - :func:`jax.numpy.less_equal`: Returns element-wise truth value of ``x <= y``. - :func:`jax.numpy.greater`: Returns element-wise truth value of ``x > y``. - :func:`jax.numpy.less`: Returns element-wise truth value of ``x < y``. Examples: >>> jnp.equal(0., -0.) Array(True, dtype=bool, weak_type=True) >>> jnp.equal(1, 1.) Array(True, dtype=bool, weak_type=True) >>> jnp.equal(5, jnp.array(5)) Array(True, dtype=bool, weak_type=True) >>> jnp.equal(2, -2) Array(False, dtype=bool, weak_type=True) >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9]]) >>> y = jnp.array([1, 5, 9]) >>> jnp.equal(x, y) Array([[ True, False, False], [False, True, False], [False, False, True]], dtype=bool) >>> x == y Array([[ True, False, False], [False, True, False], [False, False, True]], dtype=bool) equal)r eqrrs r'rrs^ gq!, --r)c<tjtd||S)a@Returns element-wise truth value of ``x != y``. JAX implementation of :obj:`numpy.not_equal`. This function provides the implementation of the ``!=`` operator for JAX arrays. Args: x: input array or scalar. y: input array or scalar. ``x`` and ``y`` should either have same shape or be broadcast compatible. Returns: A boolean array containing ``True`` where the elements of ``x != y`` and ``False`` otherwise. See also: - :func:`jax.numpy.equal`: Returns element-wise truth value of ``x == y``. - :func:`jax.numpy.greater_equal`: Returns element-wise truth value of ``x >= y``. - :func:`jax.numpy.less_equal`: Returns element-wise truth value of ``x <= y``. - :func:`jax.numpy.greater`: Returns element-wise truth value of ``x > y``. - :func:`jax.numpy.less`: Returns element-wise truth value of ``x < y``. Examples: >>> jnp.not_equal(0., -0.) Array(False, dtype=bool, weak_type=True) >>> jnp.not_equal(-2, 2) Array(True, dtype=bool, weak_type=True) >>> jnp.not_equal(1, 1.) Array(False, dtype=bool, weak_type=True) >>> jnp.not_equal(5, jnp.array(5)) Array(False, dtype=bool, weak_type=True) >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9]]) >>> y = jnp.array([1, 5, 9]) >>> jnp.not_equal(x, y) Array([[False, True, True], [ True, False, True], [ True, True, False]], dtype=bool) >>> x != y Array([[False, True, True], [ True, False, True], [ True, True, False]], dtype=bool) not_equal)r r4rrs r'rrs^ k1a0 11r)c>|j|j|S)z"Implementation of jnp.subtract.at.)rJsubtractrs r' _subtract_atrs g   ""r))rGrJcjtjtd||}tj||S)aSubtract two arrays element-wise. JAX implementation of :obj:`numpy.subtract`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. This function provides the implementation of the ``-`` operator for JAX arrays. Args: x, y: arrays to subtract. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise subtraction. Examples: Calling ``subtract`` explicitly: >>> x = jnp.arange(4) >>> jnp.subtract(x, 10) Array([-10, -9, -8, -7], dtype=int32) Calling ``subtract`` via the ``-`` operator: >>> x - 10 Array([-10, -9, -8, -7], dtype=int32) r)r subrrrrsrs r'rrs.6 j!Q/0# c" *r)c<tjtd||S)aCompute the arctangent of x1/x2, choosing the correct quadrant. JAX implementation of :func:`numpy.arctan2` Args: x1: numerator array. x2: denomniator array; should be broadcast-compatible with x1. Returns: The elementwise arctangent of x1 / x2, tracking the correct quadrant. See also: - :func:`jax.numpy.tan`: compute the tangent of an angle - :func:`jax.numpy.atan2`: the array API version of this function. Examples: Consider a sequence of angles in radians between 0 and :math:`2\pi`: >>> theta = jnp.linspace(-jnp.pi, jnp.pi, 9) >>> with jnp.printoptions(precision=2, suppress=True): ... print(theta) [-3.14 -2.36 -1.57 -0.79 0. 0.79 1.57 2.36 3.14] These angles can equivalently be represented by ``(x, y)`` coordinates on a unit circle: >>> x, y = jnp.cos(theta), jnp.sin(theta) To reconstruct the input angle, we might be tempted to use the identity :math:`\tan(\theta) = y / x`, and compute :math:`\theta = \tan^{-1}(y/x)`. Unfortunately, this does not recover the input angle: >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.arctan(y / x)) [-0. 0.79 1.57 -0.79 0. 0.79 1.57 -0.79 0. ] The problem is that :math:`y/x` contains some ambiguity: although :math:`(y, x) = (-1, -1)` and :math:`(y, x) = (1, 1)` represent different points in Cartesian space, in both cases :math:`y / x = 1`, and so the simple arctan approach loses information about which quadrant the angle lies in. :func:`arctan2` is built to address this: >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.arctan2(y, x)) [ 3.14 -2.36 -1.57 -0.79 0. 0.79 1.57 2.36 -3.14] The results match the input ``theta``, except at the endpoints where :math:`+\pi` and :math:`-\pi` represent indistinguishable points on the unit circle. By convention, :func:`arctan2` always returns values between :math:`-\pi` and :math:`+\pi` inclusive. arctan2)r atan2rx1x2s r'rr%sj (B; <>> x = jnp.array([2, 3, 5, 1]) >>> y = jnp.array([-3, 6, -4, 7]) >>> jnp.minimum(x, y) Array([-3, 3, -4, 1], dtype=int32) Inputs having broadcast compatibility: >>> x1 = jnp.array([[1, 5, 2], ... [-3, 4, 7]]) >>> y1 = jnp.array([-2, 3, 6]) >>> jnp.minimum(x1, y1) Array([[-2, 3, 2], [-3, 3, 6]], dtype=int32) Inputs with ``nan``: >>> nan = jnp.nan >>> x2 = jnp.array([[2.5, nan, -2], ... [nan, 5, 6], ... [-4, 3, 7]]) >>> y2 = jnp.array([1, nan, 5]) >>> jnp.minimum(x2, y2) Array([[ 1., nan, -2.], [nan, nan, 5.], [-4., nan, 5.]], dtype=float32) minimum)r minrrs r'rr]sr ,y!Q/ 00r)c<tjtd||S)a`Return element-wise maximum of the input arrays. JAX implementation of :obj:`numpy.maximum`. Args: x: input array or scalar. y: input array or scalar. Both ``x`` and ``y`` should either have same shape or be broadcast compatible. Returns: An array containing the element-wise maximum of ``x`` and ``y``. Note: For each pair of elements, ``jnp.maximum`` returns: - larger of the two if both elements are finite numbers. - ``nan`` if one element is ``nan``. See also: - :func:`jax.numpy.minimum`: Returns element-wise minimum of the input arrays. - :func:`jax.numpy.fmax`: Returns element-wise maximum of the input arrays, ignoring NaNs. - :func:`jax.numpy.amax`: Returns the maximum of array elements along a given axis. - :func:`jax.numpy.nanmax`: Returns the maximum of the array elements along a given axis, ignoring NaNs. Examples: Inputs with ``x.shape == y.shape``: >>> x = jnp.array([1, -5, 3, 2]) >>> y = jnp.array([-2, 4, 7, -6]) >>> jnp.maximum(x, y) Array([1, 4, 7, 2], dtype=int32) Inputs with broadcast compatibility: >>> x1 = jnp.array([[-2, 5, 7, 4], ... [1, -6, 3, 8]]) >>> y1 = jnp.array([-5, 3, 6, 9]) >>> jnp.maximum(x1, y1) Array([[-2, 5, 7, 9], [ 1, 3, 6, 9]], dtype=int32) Inputs having ``nan``: >>> nan = jnp.nan >>> x2 = jnp.array([nan, -3, 9]) >>> y2 = jnp.array([[4, -2, nan], ... [-3, -5, 10]]) >>> jnp.maximum(x2, y2) Array([[nan, -2., nan], [nan, -3., 10.]], dtype=float32) maximum)r maxrrs r'rrsp ,y!Q/ 00r)cjtjtd||}tj||S)aCalculate element-wise base ``x`` exponential of ``y``. JAX implementation of :obj:`numpy.float_power`. Args: x: scalar or array. Specifies the bases. y: scalar or array. Specifies the exponents. ``x`` and ``y`` should either have same shape or be broadcast compatible. Returns: An array containing the base ``x`` exponentials of ``y``, promoting to the inexact dtype. See also: - :func:`jax.numpy.exp`: Calculates element-wise exponential of the input. - :func:`jax.numpy.exp2`: Calculates base-2 exponential of each element of the input. Examples: Inputs with same shape: >>> x = jnp.array([3, 1, -5]) >>> y = jnp.array([2, 4, -1]) >>> jnp.float_power(x, y) Array([ 9. , 1. , -0.2], dtype=float32) Inputs with broadcast compatibility: >>> x1 = jnp.array([[2, -4, 1], ... [-1, 2, 3]]) >>> y1 = jnp.array([-2, 1, 4]) >>> jnp.float_power(x1, y1) Array([[ 0.25, -4. , 1. ], [ 1. , 2. , 81. ]], dtype=float32) ``jnp.float_power`` produces ``nan`` for negative values raised to a non-integer values. >>> jnp.float_power(-3, 1.7) Array(nan, dtype=float32, weak_type=True) float_power)r powrrrrsrs r'rrs0X %mQ:;# c" *r)c<tjtd||S)aReturn element-wise next floating point value after ``x`` towards ``y``. JAX implementation of :obj:`numpy.nextafter`. Args: x: scalar or array. Specifies the value after which the next number is found. y: scalar or array. Specifies the direction towards which the next number is found. ``x`` and ``y`` should either have same shape or be broadcast compatible. Returns: An array containing the next representable number of ``x`` in the direction of ``y``. Examples: >>> jnp.nextafter(2, 1) # doctest: +SKIP Array(1.9999999, dtype=float32, weak_type=True) >>> x = jnp.array([3, -2, 1]) >>> y = jnp.array([2, -1, 2]) >>> jnp.nextafter(x, y) # doctest: +SKIP Array([ 2.9999998, -1.9999999, 1.0000001], dtype=float32) nextafter)r rrrs r'rrs2 ,[!Q? @@r)ctd|\}tj|jdr t dt |t j}tj|jj}|jdk(rtj|||z Stj|t|||z }t|dk(t|||S)a=Return the spacing between ``x`` and the next adjacent number. JAX implementation of :func:`numpy.spacing`. Args: x: real-valued array. Integer or boolean types will be cast to float. Returns: Array of same shape as ``x`` containing spacing between each entry of ``x`` and its closest adjacent value. See also: - :func:`jax.numpy.nextafter`: find the next representable value. Examples: >>> x = jnp.array([0.0, 0.25, 0.5, 0.75, 1.0], dtype='float32') >>> jnp.spacing(x) Array([1.4012985e-45, 2.9802322e-08, 5.9604645e-08, 5.9604645e-08, 1.1920929e-07], dtype=float32) For ``x = 1``, the spacing is equal to the ``eps`` value given by :class:`jax.numpy.finfo`: >>> x = jnp.float32(1) >>> jnp.spacing(x) == jnp.finfo(x.dtype).eps Array(True, dtype=bool) spacingzcomplex floatingz.jnp.spacing is not defined for complex inputs.float16r)rrrkr" ValueErrorr5r#inffinfosmallest_subnormalr rcopysignr)r%arrrrrs r'rr!s< i +$# ^^CII12 E FF3#||CII.AA YY) ==c "S (( ]]3c 2 3c 9F &A+x(:C@& IIr)c Xtjttt d||S)aCompute the logical AND operation elementwise. JAX implementation of :obj:`numpy.logical_and`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. Args: x, y: input arrays. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise logical AND. Examples: >>> x = jnp.arange(4) >>> jnp.logical_and(x, 1) Array([False, True, True, True], dtype=bool) logical_and)r rmapr6rrs r'rrN#$ #h ]Aq(IJ KKr)Fc Xtjttt d||S)aCompute the logical OR operation elementwise. JAX implementation of :obj:`numpy.logical_or`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. Args: x, y: input arrays. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise logical OR. Examples: >>> x = jnp.arange(4) >>> jnp.logical_or(x, 1) Array([ True, True, True, True], dtype=bool) logical_or)r rrr6rrs r'rrcs#$ X|L!Q'GH IIr)c Xtjttt d||S)aCompute the logical XOR operation elementwise. JAX implementation of :obj:`numpy.logical_xor`. This is a universal function, and supports the additional APIs described at :class:`jax.numpy.ufunc`. Args: x, y: input arrays. Must be broadcastable to a common shape. Returns: Array containing the result of the element-wise logical XOR. Examples: >>> x = jnp.arange(4) >>> jnp.logical_xor(x, 1) Array([ True, False, False, False], dtype=bool) logical_xor)r rrr6rrs r'rrxrr)c Vtjttt d|S)a\Compute NOT bool(x) element-wise. JAX implementation of :func:`numpy.logical_not`. Args: x: input array of any dtype. Returns: A boolean array that computes NOT bool(x) element-wise See also: - :func:`jax.numpy.invert` or :func:`jax.numpy.bitwise_invert`: bitwise NOT operation Examples: Compute NOT x element-wise on a boolean array: >>> x = jnp.array([True, False, True]) >>> jnp.logical_not(x) Array([False, True, False], dtype=bool) For boolean input, this is equivalent to :func:`~jax.numpy.invert`, which implements the unary ``~`` operator: >>> ~x Array([False, True, False], dtype=bool) For non-boolean input, the input of :func:`logical_not` is implicitly cast to boolean: >>> x = jnp.array([-1, 0, 1]) >>> jnp.logical_not(x) Array([False, True, False], dtype=bool) logical_not)r r[rr6rr0s r'rrs"F #h ]A(FG HHr)cZtj|jtjrut j t j|j|j||j|j||j|jS|||Sr+) rrSr"r#rTr r,rr.imag)lax_opr%rs r'_complex_comparisonrst qww 2 23 ::cffQVVQVV,QVVQVV,QVVQVV, .. 1r)cLttjgtd||S)aReturn element-wise truth value of ``x >= y``. JAX implementation of :obj:`numpy.greater_equal`. Args: x: input array or scalar. y: input array or scalar. ``x`` and ``y`` must either have same shape or be broadcast compatible. Returns: An array containing boolean values. ``True`` if the elements of ``x >= y``, and ``False`` otherwise. See also: - :func:`jax.numpy.less_equal`: Returns element-wise truth value of ``x <= y``. - :func:`jax.numpy.greater`: Returns element-wise truth value of ``x > y``. - :func:`jax.numpy.less`: Returns element-wise truth value of ``x < y``. Examples: Scalar inputs: >>> jnp.greater_equal(4, 7) Array(False, dtype=bool, weak_type=True) Inputs with same shape: >>> x = jnp.array([2, 5, -1]) >>> y = jnp.array([-6, 4, 3]) >>> jnp.greater_equal(x, y) Array([ True, True, False], dtype=bool) Inputs with broadcast compatibility: >>> x1 = jnp.array([[3, -1, 4], ... [5, 9, -6]]) >>> y1 = jnp.array([-1, 4, 2]) >>> jnp.greater_equal(x1, y1) Array([[ True, False, True], [ True, True, False]], dtype=bool) greater_equal)rr gerrs r'rrs"V SVV Jl?Aq&I JJr)cLttjgtd||S)aReturn element-wise truth value of ``x > y``. JAX implementation of :obj:`numpy.greater`. Args: x: input array or scalar. y: input array or scalar. ``x`` and ``y`` must either have same shape or be broadcast compatible. Returns: An array containing boolean values. ``True`` if the elements of ``x > y``, and ``False`` otherwise. See also: - :func:`jax.numpy.less`: Returns element-wise truth value of ``x < y``. - :func:`jax.numpy.greater_equal`: Returns element-wise truth value of ``x >= y``. - :func:`jax.numpy.less_equal`: Returns element-wise truth value of ``x <= y``. Examples: Scalar inputs: >>> jnp.greater(5, 2) Array(True, dtype=bool, weak_type=True) Inputs with same shape: >>> x = jnp.array([5, 9, -2]) >>> y = jnp.array([4, -1, 6]) >>> jnp.greater(x, y) Array([ True, True, False], dtype=bool) Inputs with broadcast compatibility: >>> x1 = jnp.array([[5, -6, 7], ... [-2, 5, 9]]) >>> y1 = jnp.array([-4, 3, 10]) >>> jnp.greater(x1, y1) Array([[ True, False, False], [ True, True, False]], dtype=bool) greater)rr gtrrs r'rrs"X SVV Dl9a&C DDr)cLttjgtd||S)aReturn element-wise truth value of ``x <= y``. JAX implementation of :obj:`numpy.less_equal`. Args: x: input array or scalar. y: input array or scalar. ``x`` and ``y`` must have either same shape or be broadcast compatible. Returns: An array containing the boolean values. ``True`` if the elements of ``x <= y``, and ``False`` otherwise. See also: - :func:`jax.numpy.greater_equal`: Returns element-wise truth value of ``x >= y``. - :func:`jax.numpy.greater`: Returns element-wise truth value of ``x > y``. - :func:`jax.numpy.less`: Returns element-wise truth value of ``x < y``. Examples: Scalar inputs: >>> jnp.less_equal(6, -2) Array(False, dtype=bool, weak_type=True) Inputs with same shape: >>> x = jnp.array([-4, 1, 7]) >>> y = jnp.array([2, -3, 8]) >>> jnp.less_equal(x, y) Array([ True, False, True], dtype=bool) Inputs with broadcast compatibility: >>> x1 = jnp.array([2, -5, 9]) >>> y1 = jnp.array([[1, -6, 5], ... [-2, 4, -6]]) >>> jnp.less_equal(x1, y1) Array([[False, False, False], [False, True, False]], dtype=bool) less_equal)rr lerrs r'rrs"X SVV Gl<A&F GGr)cLttjgtd||S)aReturn element-wise truth value of ``x < y``. JAX implementation of :obj:`numpy.less`. Args: x: input array or scalar. y: input array or scalar. ``x`` and ``y`` must either have same shape or be broadcast compatible. Returns: An array containing boolean values. ``True`` if the elements of ``x < y``, and ``False`` otherwise. See also: - :func:`jax.numpy.greater`: Returns element-wise truth value of ``x > y``. - :func:`jax.numpy.greater_equal`: Returns element-wise truth value of ``x >= y``. - :func:`jax.numpy.less_equal`: Returns element-wise truth value of ``x <= y``. Examples: Scalar inputs: >>> jnp.less(3, 7) Array(True, dtype=bool, weak_type=True) Inputs with same shape: >>> x = jnp.array([5, 9, -3]) >>> y = jnp.array([1, 6, 4]) >>> jnp.less(x, y) Array([False, False, True], dtype=bool) Inputs with broadcast compatibility: >>> x1 = jnp.array([[2, -4, 6, -8], ... [-1, 5, -3, 7]]) >>> y1 = jnp.array([0, 3, -5, 9]) >>> jnp.less(x1, y1) Array([[False, True, False, True], [ True, False, False, True]], dtype=bool) less)rr ltrrs r'rrHs"X SVV Al61a&@ AAr)c&ttd|S)z!Alias of :func:`jax.numpy.arccos`r)rrr0s r'rrx fa( ))r)c&ttd|S)z"Alias of :func:`jax.numpy.arccosh`r)rrr0s r'rr ,w* ++r)c&ttd|S)z!Alias of :func:`jax.numpy.arcsin`r)rrr0s r'rrrr)c&ttd|S)z"Alias of :func:`jax.numpy.arcsinh`r)rrr0s r'rrrr)c&ttd|S)z!Alias of :func:`jax.numpy.arctan`r)rrr0s r'rrrr)c&ttd|S)z"Alias of :func:`jax.numpy.arctanh`r)rrr0s r'rrrr)c(ttd||S)z"Alias of :func:`jax.numpy.arctan2`r)rrrs r'rrs ,wB/ 00r)cxtd|\}tjt|j dS)aCounts the number of 1 bits in the binary representation of the absolute value of each element of ``x``. JAX implementation of :obj:`numpy.bitwise_count`. Args: x: Input array, only accepts integer subtypes Returns: An array-like object containing the binary 1 bit counts of the absolute value of each element in ``x``, with the same shape as ``x`` of dtype uint8. Examples: >>> x1 = jnp.array([64, 32, 31, 20]) >>> # 64 = 0b1000000, 32 = 0b100000, 31 = 0b11111, 20 = 0b10100 >>> jnp.bitwise_count(x1) Array([1, 1, 5, 2], dtype=uint8) >>> x2 = jnp.array([-16, -7, 7]) >>> # |-16| = 0b10000, |-7| = 0b111, 7 = 0b111 >>> jnp.bitwise_count(x2) Array([1, 3, 3], dtype=uint8) >>> x3 = jnp.array([[2, -7],[-9, 7]]) >>> # 2 = 0b10, |-7| = 0b111, |-9| = 0b1001, 7 = 0b111 >>> jnp.bitwise_count(x3) Array([[1, 3], [2, 3]], dtype=uint8) bitwise_countuint8)rr population_countrVrr0s r'rrs3@OQ/"!  c!f % , ,W 55r)cttjj||\}}tj|j tj rtjntj}|||S)aIRight shift the bits of ``x1`` to the amount specified in ``x2``. JAX implementation of :obj:`numpy.right_shift`. Args: x1: Input array, only accepts unsigned integer subtypes x2: The amount of bits to shift each element in ``x1`` to the right, only accepts integer subtypes Returns: An array-like object containing the right shifted elements of ``x1`` by the amount specified in ``x2``, with the same shape as the broadcasted shape of ``x1`` and ``x2``. Note: If ``x1.shape != x2.shape``, they must be compatible for broadcasting to a shared shape, this shared shape will also be the shape of the output. Right shifting a scalar x1 by scalar x2 is equivalent to ``x1 // 2**x2``. Examples: >>> def print_binary(x): ... return [bin(int(val)) for val in x] >>> x1 = jnp.array([1, 2, 4, 8]) >>> print_binary(x1) ['0b1', '0b10', '0b100', '0b1000'] >>> x2 = 1 >>> result = jnp.right_shift(x1, x2) >>> result Array([0, 1, 2, 4], dtype=int32) >>> print_binary(result) ['0b0', '0b1', '0b10', '0b100'] >>> x1 = 16 >>> print_binary([x1]) ['0b10000'] >>> x2 = jnp.array([1, 2, 3, 4]) >>> result = jnp.right_shift(x1, x2) >>> result Array([8, 4, 2, 1], dtype=int32) >>> print_binary(result) ['0b1000', '0b100', '0b10', '0b1'] ) rr# right_shiftr@rSr"unsignedintegerr shift_right_logicalshift_right_arithmetic)rrlax_fns r'r r s^\  7 7R @&"bMM"((B../  " "585O5O Br)ct||S)z'Alias of :func:`jax.numpy.right_shift`.)r rs r'bitwise_right_shiftr s R r)ctd|}tj|}|tjk(s$tj |tj rtj|Stj|S)aCalculate the absolute value element-wise. JAX implementation of :obj:`numpy.absolute`. This is the same function as :func:`jax.numpy.abs`. Args: x: Input array Returns: An array-like object containing the absolute value of each element in ``x``, with the same shape as ``x``. For complex valued input, :math:`a + ib`, the absolute value is :math:`\sqrt{a^2+b^2}`. Examples: >>> x1 = jnp.array([5, -2, 0, 12]) >>> jnp.absolute(x1) Array([ 5, 2, 0, 12], dtype=int32) >>> x2 = jnp.array([[ 8, -3, 1],[ 0, 9, -6]]) >>> jnp.absolute(x2) Array([[8, 3, 1], [0, 9, 6]], dtype=int32) >>> x3 = jnp.array([8 + 15j, 3 - 4j, -5 + 0j]) >>> jnp.absolute(x3) Array([17., 5., 5.], dtype=float32) absolute) rrr"r#bool_rSr r rdrV)r%dts r'rr s\>z1%! ||A">V->->r2CUCU-VQf\_\c\cde\ffr)ct|S)z$Alias of :func:`jax.numpy.absolute`.)rr0s r'rVrV- s !r)c&td|}tj|}|tk(s$tj|t j r$tj|tjStj|t jrNtjttj|ttj|Stj|tj j"S)aRounds the elements of x to the nearest integer JAX implementation of :obj:`numpy.rint`. Args: x: Input array Returns: An array-like object containing the rounded elements of ``x``. Always promotes to inexact. Note: If an element of x is exactly half way, e.g. ``0.5`` or ``1.5``, rint will round to the nearest even integer. Examples: >>> x1 = jnp.array([5, 4, 7]) >>> jnp.rint(x1) Array([5., 4., 7.], dtype=float32) >>> x2 = jnp.array([-2.5, -1.5, -0.5, 0.5, 1.5, 2.5, 3.5, 4.5]) >>> jnp.rint(x2) Array([-2., -2., -0., 0., 2., 2., 4., 4.], dtype=float32) >>> x3 = jnp.array([-2.5+3.5j, 4.5-0.5j]) >>> jnp.rint(x3) Array([-2.+4.j, 4.-0.j], dtype=complex64) rint)rrr"r3rSr#integerr rfloat_rTcomplexrr.rroundRoundingMethodTO_NEAREST_EVENr%r"s r'rr4 s>vq!! ,,q/% d]f''rzz:  # #Av}} 55 ub001 ;;tCHHQK($sxx{*; << 1c((88 99r)cFtd||\}}tjtj|tj r t dtt|jttj| tj|S)aCopies the sign of each element in ``x2`` to the corresponding element in ``x1``. JAX implementation of :obj:`numpy.copysign`. Args: x1: Input array x2: The array whose elements will be used to determine the sign, must be broadcast-compatible with ``x1`` Returns: An array object containing the potentially changed elements of ``x1``, always promotes to inexact dtype, and has a shape of ``jnp.broadcast_shapes(x1.shape, x2.shape)`` Examples: >>> x1 = jnp.array([5, 2, 0]) >>> x2 = -1 >>> jnp.copysign(x1, x2) Array([-5., -2., -0.], dtype=float32) >>> x1 = jnp.array([6, 8, 0]) >>> x2 = 2 >>> jnp.copysign(x1, x2) Array([6., 8., 0.], dtype=float32) >>> x1 = jnp.array([2, -3]) >>> x2 = jnp.array([[1],[-4], [5]]) >>> jnp.copysign(x1, x2) Array([[ 2., 3.], [-2., -3.], [ 2., 3.]], dtype=float32) rz/copysign does not support complex-valued inputs) rrrSr"r#rTrUrsignbitrr3r rVrs r'rr\ srD B 3&"b v||B'););< E FF  ""4(3772;, DDr)ctd||\}}tj|tj||}tj ||S)a=Calculates the division of x1 by x2 element-wise JAX implementation of :func:`numpy.true_divide`. Args: x1: Input array, the dividend x2: Input array, the divisor Returns: An array containing the elementwise quotients, will always use floating point division. Examples: >>> x1 = jnp.array([3, 4, 5]) >>> x2 = 2 >>> jnp.true_divide(x1, x2) Array([1.5, 2. , 2.5], dtype=float32) >>> x1 = 24 >>> x2 = jnp.array([3, 4, 6j]) >>> jnp.true_divide(x1, x2) Array([8.+0.j, 6.+0.j, 0.-4.j], dtype=complex64) >>> x1 = jnp.array([1j, 9+5j, -4+2j]) >>> x2 = 3j >>> jnp.true_divide(x1, x2) Array([0.33333334+0.j , 1.6666666 -3.j , 0.6666667 +1.3333334j], dtype=complex64) See Also: :func:`jax.numpy.floor_divide` for integer division true_divide)rrr_set_error_if_divide_by_zeror divrsrrrus r'r$r$ sGF r2 6&"b ((, B# c" *r)ct||S)z'Alias of :func:`jax.numpy.true_divide`.)r$rs r'divider) s R r)ctd||\}}tj|tj|}tj |t jrtj||Stj |t jrrtj||}ttj|tj|k7tj||dk7}t||dz |Stj |t jr t!dt#||dS)aMCalculates the floor division of x1 by x2 element-wise JAX implementation of :obj:`numpy.floor_divide`. Args: x1: Input array, the dividend x2: Input array, the divisor Returns: An array-like object containing each of the quotients rounded down to the nearest integer towards negative infinity. This is equivalent to ``x1 // x2`` in Python. Note: ``x1 // x2`` is equivalent to ``jnp.floor_divide(x1, x2)`` for arrays ``x1`` and ``x2`` See Also: :func:`jax.numpy.divide` and :func:`jax.numpy.true_divide` for floating point division. Examples: >>> x1 = jnp.array([10, 20, 30]) >>> x2 = jnp.array([3, 4, 7]) >>> jnp.floor_divide(x1, x2) Array([3, 5, 4], dtype=int32) >>> x1 = jnp.array([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]) >>> x2 = 3 >>> jnp.floor_divide(x1, x2) Array([-2, -2, -1, -1, -1, 0, 0, 0, 1, 1, 1], dtype=int32) >>> x1 = jnp.array([6, 6, 6], dtype=jnp.int32) >>> x2 = jnp.array([2.0, 2.5, 3.0], dtype=jnp.float32) >>> jnp.floor_divide(x1, x2) Array([3., 2., 2.], dtype=float32) floor_dividerr:z3floor_divide does not support complex-valued inputs)rrrr%rr"rSr#r r r&rrrfremrrTrU _float_divmod)rrr"quotientr,s r'r+r+ sP B 7&"b ((, ,,r % ub001 772r?  +wwr2H ""5swwr2!7K LF &(Q, 11  2 23 I JJ R  ##r)ctd||\}}tjtj|tj rt ||t||fStj|t||S)aCalculates the integer quotient and remainder of x1 by x2 element-wise JAX implementation of :obj:`numpy.divmod`. Args: x1: Input array, the dividend x2: Input array, the divisor Returns: A tuple of arrays ``(x1 // x2, x1 % x2)``. See Also: - :func:`jax.numpy.floor_divide`: floor division function - :func:`jax.numpy.remainder`: remainder function Examples: >>> x1 = jnp.array([10, 20, 30]) >>> x2 = jnp.array([3, 4, 7]) >>> jnp.divmod(x1, x2) (Array([3, 5, 4], dtype=int32), Array([1, 0, 2], dtype=int32)) >>> x1 = jnp.array([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4, 5]) >>> x2 = 3 >>> jnp.divmod(x1, x2) (Array([-2, -2, -1, -1, -1, 0, 0, 0, 1, 1, 1], dtype=int32), Array([1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2], dtype=int32)) >>> x1 = jnp.array([6, 6, 6], dtype=jnp.int32) >>> x2 = jnp.array([1.9, 2.5, 3.1], dtype=jnp.float32) >>> jnp.divmod(x1, x2) (Array([3., 2., 1.], dtype=float32), Array([0.30000007, 1. , 2.9 ], dtype=float32)) divmod) rrrSr"r#rr+ remainderrrr%r-rs r'r0r0 shH "b 1&"b v||B'4 B 2r!2 22 **2. R  r)ctj||}tjtj|||}tj|dk7tj |tj |k7}tj |||z|}tj ||t|dz |}tj||fS)Nrr:) r r,r&rrrfr,r(r)rrmodr&inds r'r-r- s B# C "%# q#((2,#((3-"?@# 3b#&# 3nS!44c:# 3 r)ctd||t|dr|jn|}t|dr|jn|}td||t j |r9 t j|}t|\}tj||St||}tj||S#t$rY.wxYw)aCalculate element-wise base ``x1`` exponential of ``x2``. JAX implementation of :obj:`numpy.power`. Args: x1: scalar or array. Specifies the bases. x2: scalar or array. Specifies the exponent. ``x1`` and ``x2`` should either have same shape or be broadcast compatible. Returns: An array containing the base ``x1`` exponentials of ``x2`` with same dtype as input. Note: - When ``x2`` is a concrete integer scalar, ``jnp.power`` lowers to :func:`jax.lax.integer_pow`. - When ``x2`` is a traced scalar or an array, ``jnp.power`` lowers to :func:`jax.lax.pow`. - ``jnp.power`` raises a ``TypeError`` for integer type raised to a concrete negative integer power. For a non-concrete power, the operation is invalid and the returned value is implementation-defined. - ``jnp.power`` returns ``nan`` for negative value raised to the power of non-integer values. See also: - :func:`jax.lax.pow`: Computes element-wise power, :math:`x^y`. - :func:`jax.lax.integer_pow`: Computes element-wise power :math:`x^y`, where :math:`y` is a fixed integer. - :func:`jax.numpy.float_power`: Computes the first array raised to the power of second array, element-wise, by promoting to the inexact dtype. - :func:`jax.numpy.pow`: Computes the first array raised to the power of second array, element-wise. Examples: Inputs with scalar integers: >>> jnp.power(4, 3) Array(64, dtype=int32, weak_type=True) Inputs with same shape: >>> x1 = jnp.array([2, 4, 5]) >>> x2 = jnp.array([3, 0.5, 2]) >>> jnp.power(x1, x2) Array([ 8., 2., 25.], dtype=float32) Inputs with broadcast compatibility: >>> x3 = jnp.array([-2, 3, 1]) >>> x4 = jnp.array([[4, 1, 6], ... [1.3, 3, 5]]) >>> jnp.power(x3, x4) Array([[16., 3., 1.], [nan, 27., 1.]], dtype=float32) power __jax_array__)rhasattrr7rr is_concreteoperatorindexrr integer_powrU_powerrrrsr's r'r6r6$ sr'2r"%R9rr"$R9rr"7B#  b% >>" b #2 &cb __R $$ r2# c" *    s-C CCct||S)z Alias of :func:`jax.numpy.power`)r6rs r'rr s r2r)ctd||\}}td||\}}tjtj|t j s7tjtj|t jrCt jtj|jdksJt||Stj|tj|}}tj|t jr:tj|t j rtj||Stj||S)Nr6r)rrrrSr"r#rriinfobits _pow_int_intinexactr r)rrx1_x2_d1d2s r'r=r= s '2r *&"b"'2r 2(#s  S)2::6  S)2884 88FLL% & + +r 11 1 S !! << V\\"-b" r2::&6+<+>> x1 = jnp.array([1, 2, 3]) >>> x2 = jnp.array([4, 5, 6]) >>> result1 = jnp.logaddexp(x1, x2) >>> result2 = jnp.log(jnp.exp(x1) + jnp.exp(x2)) >>> print(jnp.allclose(result1, result2)) True logaddexp)r lax_otherrPrs r'rPrP s), R 4&"b   R $$r)cNtd||\}}tj||S)aJLogarithm of the sum of exponentials of inputs in base-2 avoiding overflow. JAX implementation of :obj:`numpy.logaddexp2`. Args: x1: input array or scalar. x2: input array or scalar. ``x1`` and ``x2`` should either have same shape or be broadcast compatible. Returns: An array containing the result, :math:`log_2(2^{x1}+2^{x2})`, element-wise. See also: - :func:`jax.numpy.logaddexp`: Computes ``log(exp(x1) + exp(x2))``, element-wise. - :func:`jax.numpy.log2`: Calculates the base-2 logarithm of ``x`` element-wise. Examples: >>> x1 = jnp.array([[3, -1, 4], ... [8, 5, -2]]) >>> x2 = jnp.array([2, 3, -5]) >>> result1 = jnp.logaddexp2(x1, x2) >>> result2 = jnp.log2(jnp.exp2(x1) + jnp.exp2(x2)) >>> jnp.allclose(result1, result2) Array(True, dtype=bool) logaddexp2)rrQrSrs r'rSrS s)6 b" 5&"b   b" %%r)c ltd|\}tj|jtj rt j|}t j|}t j|}t jt|d}t jt j||t j||St jt j|t jt|d}tj||S)a~Calculates the base-2 logarithm of ``x`` element-wise. JAX implementation of :obj:`numpy.log2`. Args: x: Input array Returns: An array containing the base-2 logarithm of each element in ``x``, promotes to inexact dtype. Examples: >>> x1 = jnp.array([0.25, 0.5, 1, 2, 4, 8]) >>> jnp.log2(x1) Array([-2., -1., 0., 1., 2., 3.], dtype=float32) log2rFrrrSr"r#rTr rqr.rr(rr&rrrs)r%rreimln2rus r'rUrU s&FA&"! qww 2 23  A !B !B ''.Q' (C ;;swwr3'S)9 ::  CGGN1a$89:# c" *r)c ltd|\}tj|jtj rt j|}t j|}t j|}t jt|d}t jt j||t j||St jt j|t jt|d}tj||S)aCalculates the base-10 logarithm of x element-wise JAX implementation of :obj:`numpy.log10`. Args: x: Input array Returns: An array containing the base-10 logarithm of each element in ``x``, promotes to inexact dtype. Examples: >>> x1 = jnp.array([0.01, 0.1, 1, 10, 100, 1000]) >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.log10(x1)) [-2. -1. 0. 1. 2. 3.] log10 rV)r%rWrXrYln10rus r'r\r\ s(GQ'"! qww 2 23  A !B !B 77>"b) *D ;;swwr4(#''"d*; <<  CGGN1b$9:;# c" *r)cHtd|\}tj|S)acCalculate element-wise base-2 exponential of input. JAX implementation of :obj:`numpy.exp2`. Args: x: input array or scalar Returns: An array containing the base-2 exponential of each element in ``x``, promotes to inexact dtype. See also: - :func:`jax.numpy.log2`: Calculates base-2 logarithm of each element of input. - :func:`jax.numpy.exp`: Calculates exponential of each element of the input. - :func:`jax.numpy.expm1`: Calculates :math:`e^x-1` of each element of the input. Examples: ``jnp.exp2`` follows the properties of the exponential such as :math:`2^{a+b} = 2^a * 2^b`. >>> x1 = jnp.array([2, -4, 3, -1]) >>> x2 = jnp.array([-1, 3, -2, 3]) >>> jnp.exp2(x1+x2) Array([2. , 0.5, 2. , 4. ], dtype=float32) >>> jnp.exp2(x1)*jnp.exp2(x2) Array([2. , 0.5, 2. , 4. ], dtype=float32) exp2)rr r`r0s r'r`r`! s >FA&"! !r)ctd|\}tj|}tj|tj r t j|t|dStj|tjr&t j|dtjStj|tjstd|ztj|}|jtvr t!dt|j}t j"||}t j$||j&|j(zz tjS)a Return the sign bit of array elements. JAX implementation of :obj:`numpy.signbit`. Args: x: input array. Complex values are not supported. Returns: A boolean array of the same shape as ``x``, containing ``True`` where the sign of ``x`` is negative, and ``False`` otherwise. See also: - :func:`jax.numpy.sign`: return the mathematical sign of array elements, i.e. ``-1``, ``0``, or ``+1``. Examples: :func:`signbit` on boolean values is always ``False``: >>> x = jnp.array([True, False]) >>> jnp.signbit(x) Array([False, False], dtype=bool) :func:`signbit` on integer values is equivalent to ``x < 0``: >>> x = jnp.array([-2, -1, 0, 1, 2]) >>> jnp.signbit(x) Array([ True, True, False, False, False], dtype=bool) :func:`signbit` on floating point values returns the value of the actual sign bit from the float representation, including signed zero: >>> x = jnp.array([-1.5, -0.0, 0.0, 1.5]) >>> jnp.signbit(x) Array([ True, True, False, False], dtype=bool) This also returns the sign bit for special values such as signed NaN and signed infinity: >>> x = jnp.array([jnp.nan, -jnp.nan, jnp.inf, -jnp.inf]) >>> jnp.signbit(x) Array([False, True, False, True], dtype=bool) r"rFr!z,jax.numpy.signbit is not well defined for %sz9jax.numpy.signbit only supports 16, 32, and 64-bit types.)rrr"rSr#rr rr(r full_likefloatingrrrA _INT_DTYPESNotImplementedErrorbitcast_convert_typernexpnmant)r%r"infoint_types r'r"r"D sZIq!"! ,,q/% ubjj) 66!^Aq) ** ) ==E 22   UBKK 0 6> @@ e $ YYk! C EE  #( q(+! ! !! DJJ(>"? JJr)c tjtj|}t|j}t j ||jk}t||t|d|jzz|}t|||j |d}t j|||fSNr:r) rrr"rdrAr rVtinyrr5rhrf)r%rirjcondrrs r'_normalize_floatro s fll1o &$  #( dii $ dA 1a4::o66:" dHdjj[)8A;7" ! !"h / 33r)ctd||\}}tj|}tj|}tj|tj s$tj|tj rtd||ftd|\}tj|tj|}t|\}}|j|j|zj|j}t|dkD|dz|}t|dkD|dz |}|d|j|jzz}tt||dk(z||S)aCompute x1 * 2 ** x2 JAX implementation of :func:`numpy.ldexp`. Note that XLA does not provide an ``ldexp`` operation, so this is implemneted in JAX via a standard multiplication and exponentiation. Args: x1: real-valued input array. x2: integer input array. Must be broadcast-compatible with ``x1``. Returns: ``x1 * 2 ** x2`` computed element-wise. See also: - :func:`jax.numpy.frexp`: decompose values into mantissa and exponent. Examples: >>> x1 = jnp.arange(5.0) >>> x2 = 10 >>> jnp.ldexp(x1, x2) Array([ 0., 1024., 2048., 3072., 4096.], dtype=float32) ``ldexp`` can be used to reconstruct the input to ``frexp``: >>> x = jnp.array([2., 3., 5., 11.]) >>> m, e = jnp.frexp(x) >>> m Array([0.5 , 0.75 , 0.625 , 0.6875], dtype=float32) >>> e Array([2, 2, 3, 4], dtype=int32) >>> jnp.ldexp(m, e) Array([ 2., 3., 5., 11.], dtype=float32) ldexpz$ldexp not supported for input types rrFr:)rrr"rSr#rTrCrrr rfrexprrisinf)rrx1_dtypex2_dtypemer%s r'rqrq s:L GR ,&"b \\" ( \\" ( ""4"45   8RZZ 0 ;Xx>> x = jnp.array([1., 2., 3., 4., 5.]) >>> m, e = jnp.frexp(x) >>> m Array([0.5 , 0.5 , 0.75 , 0.5 , 0.625], dtype=float32) >>> e Array([1, 2, 2, 3, 3], dtype=int32) Reconstruct the original array: >>> m * 2 ** e Array([1., 2., 3., 4., 5.], dtype=float32) rrz,frexp does not support complex-valued inputs) rrrrSr"r#rTrU_frexpr0s r'rrrr sMBw"!a "! qww 2 23 B CC r)cBtj|}tj|}d|jzdz }d|jz }t |\}}|||j z |z|z dzz }|||j zz}||dz |j zz}tj||}t|t|z|dk(z}t|tj||}t|||tj|tjfSrl)rr"rrgminexprorhr rfrsisnanrr/rr#r)r%r"rimaskbiasrrrns r'ryry s ,,q/% e $ tyy.A $ T[[$ A &"b" d "d*Q.."$$** "djj  " E*" qE!H Q '$ dCJJrNB'" a c66r288D DDr)c|\}|\}t|\}}|t|j|j z}t j |j tj}||f||ffSr+) rrr`rr"r#emptyshaperfloat0)primalstangentsr%trvrwmdotedots r' _frexp_jvpr sg"!"! q$!Q T188AGG$$ % %$ !''6== )$ Q$ r)c td||\}}tj|t|d}t j |j tjr#t|dk(tj||}tj||}tj||}tjtjtj||tj|||}tj |tj"|||}tj$||S)aReturns element-wise remainder of the division. JAX implementation of :obj:`numpy.remainder`. Args: x1: scalar or array. Specifies the dividend. x2: scalar or array. Specifies the divisor. ``x1`` and ``x2`` should either have same shape or be broadcast compatible. Returns: An array containing the remainder of element-wise division of ``x1`` by ``x2`` with same sign as the elements of ``x2``. Note: The result of ``jnp.remainder`` is equivalent to ``x1 - x2 * jnp.floor(x1 / x2)``. See also: - :func:`jax.numpy.mod`: Returns the element-wise remainder of the division. - :func:`jax.numpy.fmod`: Calculates the element-wise floating-point modulo operation. - :func:`jax.numpy.divmod`: Calculates the integer quotient and remainder of ``x1`` by ``x2``, element-wise. Examples: >>> x1 = jnp.array([[3, -1, 4], ... [8, 5, -2]]) >>> x2 = jnp.array([2, 3, -5]) >>> jnp.remainder(x1, x2) Array([[ 1, 2, -1], [ 0, 2, -2]], dtype=int32) >>> x1 - x2 * jnp.floor(x1 / x2) Array([[ 1., 2., -1.], [ 0., 2., -2.]], dtype=float32) r1r)rrrr%r(rrSr"r#rrr _onesr,r4rrr,rrs)rrrK trunc_modtrunc_mod_not_zerodo_plusrus r'r1r1 sJ R 4&"b ((, A $ rxx, a2 +Bggb"o)vvi. OO ffSVVIt $cffR&679K M' 7CGGIr2I># c" *r)ct||S)z$Alias of :func:`jax.numpy.remainder`)r1rs r'r3r3> s 2r r)c@td||\}}tjtj||tj r#t |dk(tj||}tjtd||}tj||S)aZCalculate element-wise floating-point modulo operation. JAX implementation of :obj:`numpy.fmod`. Args: x1: scalar or array. Specifies the dividend. x2: scalar or array. Specifies the divisor. ``x1`` and ``x2`` should either have same shape or be broadcast compatible. Returns: An array containing the result of the element-wise floating-point modulo operation of ``x1`` and ``x2`` with same sign as the elements of ``x1``. Note: The result of ``jnp.fmod`` is equivalent to ``x1 - x2 * jnp.fix(x1 / x2)``. See also: - :func:`jax.numpy.mod` and :func:`jax.numpy.remainder`: Returns the element-wise remainder of the division. - :func:`jax.numpy.divmod`: Calculates the integer quotient and remainder of ``x1`` by ``x2``, element-wise. Examples: >>> x1 = jnp.array([[3, -1, 4], ... [8, 5, -2]]) >>> x2 = jnp.array([2, 3, -5]) >>> jnp.fmod(x1, x2) Array([[ 1, -1, 4], [ 0, 2, -2]], dtype=int32) >>> x1 - x2 * jnp.fix(x1 / x2) Array([[ 1., -1., 4.], [ 0., 2., -2.]], dtype=float32) fmodr) rrrS result_typer#rrr rr,rrrrsr's r'rrD s}H FB +&"b v))"b12::> a2 +B %fb"56# c" *r)c^td|}t|\}tj|S)aCalculate element-wise square of the input array. JAX implementation of :obj:`numpy.square`. Args: x: input array or scalar. Returns: An array containing the square of the elements of ``x``. Note: ``jnp.square`` is equivalent to computing ``jnp.power(x, 2)``. See also: - :func:`jax.numpy.sqrt`: Calculates the element-wise non-negative square root of the input array. - :func:`jax.numpy.power`: Calculates the element-wise base ``x1`` exponential of ``x2``. - :func:`jax.lax.integer_pow`: Computes element-wise power :math:`x^y`, where :math:`y` is a fixed integer. - :func:`jax.numpy.float_power`: Computes the first array raised to the power of second array, element-wise, by promoting to the inexact dtype. Examples: >>> x = jnp.array([3, -2, 5.3, 1]) >>> jnp.square(x) Array([ 9. , 4. , 28.090002, 1. ], dtype=float32) >>> jnp.power(x, 2) Array([ 9. , 4. , 28.090002, 1. ], dtype=float32) For integer inputs: >>> x1 = jnp.array([2, 4, 5, 6]) >>> jnp.square(x1) Array([ 4, 16, 25, 36], dtype=int32) For complex-valued inputs: >>> x2 = jnp.array([1-3j, -1j, 2]) >>> jnp.square(x2) Array([-8.-6.j, -1.+0.j, 4.+0.j], dtype=complex64) square)rrr rr0s r'rrp s+Zx#!a "! Ar)ctd|\}tj|t|tj dz S)aConvert angles from degrees to radians. JAX implementation of :obj:`numpy.deg2rad`. The angle in degrees is converted to radians by: .. math:: deg2rad(x) = x * \frac{pi}{180} Args: x: scalar or array. Specifies the angle in degrees. Returns: An array containing the angles in radians. See also: - :func:`jax.numpy.rad2deg` and :func:`jax.numpy.degrees`: Converts the angles from radians to degrees. - :func:`jax.numpy.radians`: Alias of ``deg2rad``. Examples: >>> x = jnp.array([60, 90, 120, 180]) >>> jnp.deg2rad(x) Array([1.0471976, 1.5707964, 2.0943952, 3.1415927], dtype=float32) >>> x * jnp.pi / 180 Array([1.0471976, 1.5707964, 2.0943952, 3.1415927], dtype=float32, weak_type=True) deg2radrr rr5r#pir0s r'rr s2>Iq)"! Jq"%%#+. //r)ctd|\}tj|t|dtj z S)aConvert angles from radians to degrees. JAX implementation of :obj:`numpy.rad2deg`. The angle in radians is converted to degrees by: .. math:: rad2deg(x) = x * \frac{180}{pi} Args: x: scalar or array. Specifies the angle in radians. Returns: An array containing the angles in degrees. See also: - :func:`jax.numpy.deg2rad` and :func:`jax.numpy.radians`: Converts the angles from degrees to radians. - :func:`jax.numpy.degrees`: Alias of ``rad2deg``. Examples: >>> pi = jnp.pi >>> x = jnp.array([pi/4, pi/2, 2*pi/3]) >>> jnp.rad2deg(x) Array([ 45. , 90. , 120.00001], dtype=float32) >>> x * 180 / pi Array([ 45., 90., 120.], dtype=float32) rad2degrrr0s r'rr s3@Iq)"! Jq#+. //r)ct|S)z"Alias of :func:`jax.numpy.rad2deg`)rr0s r'degreesr  r)ct|S)z"Alias of :func:`jax.numpy.deg2rad`)rr0s r'radiansr rr)ctd|}tj|rtj|Stj |S)ajReturn element-wise complex-conjugate of the input. JAX implementation of :obj:`numpy.conjugate`. Args: x: inpuat array or scalar. Returns: An array containing the complex-conjugate of ``x``. See also: - :func:`jax.numpy.real`: Returns the element-wise real part of the complex argument. - :func:`jax.numpy.imag`: Returns the element-wise imaginary part of the complex argument. Examples: >>> jnp.conjugate(3) Array(3, dtype=int32, weak_type=True) >>> x = jnp.array([2-1j, 3+5j, 7]) >>> jnp.conjugate(x) Array([2.+1.j, 3.-5.j, 7.-0.j], dtype=complex64) conjugate)rr# iscomplexobjr conjrdr0s r'rr s64{A&!*!> A>r)ct|S)z$Alias of :func:`jax.numpy.conjugate`)rr0s r'rr s 1r)ctd|}tj|rtj|Stj |dS)aReturn element-wise imaginary of part of the complex argument. JAX implementation of :obj:`numpy.imag`. Args: val: input array or scalar. Returns: An array containing the imaginary part of the elements of ``val``. See also: - :func:`jax.numpy.conjugate` and :func:`jax.numpy.conj`: Returns the element-wise complex-conjugate of the input. - :func:`jax.numpy.real`: Returns the element-wise real part of the complex argument. Examples: >>> jnp.imag(4) Array(0, dtype=int32, weak_type=True) >>> jnp.imag(5j) Array(5., dtype=float32, weak_type=True) >>> x = jnp.array([2+3j, 5-1j, -3]) >>> jnp.imag(x) Array([ 3., -1., 0.], dtype=float32) rr)rr#rr rrbvals r'rr s98 %#//#.#ICMM#q4IIr)ctd|}tj|rtj|Stj |S)aReturn element-wise real part of the complex argument. JAX implementation of :obj:`numpy.real`. Args: val: input array or scalar. Returns: An array containing the real part of the elements of ``val``. See also: - :func:`jax.numpy.conjugate` and :func:`jax.numpy.conj`: Returns the element-wise complex-conjugate of the input. - :func:`jax.numpy.imag`: Returns the element-wise imaginary part of the complex argument. Examples: >>> jnp.real(5) Array(5, dtype=int32, weak_type=True) >>> jnp.real(2j) Array(0., dtype=float32, weak_type=True) >>> x = jnp.array([3-2j, 4+7j, -2j]) >>> jnp.real(x) Array([ 3., 4., -0.], dtype=float32) r.)rr#rr r.rdrs r'r.r.9 s78 %#//#.#DCKK4DDr)ctd|}t|\}| tdtt j |t j |t|t|}||z |fS)aReturn element-wise fractional and integral parts of the input array. JAX implementation of :obj:`numpy.modf`. Args: x: input array or scalar. out: Not used by JAX. Returns: An array containing the fractional and integral parts of the elements of ``x``, promoting dtypes inexact. See also: - :func:`jax.numpy.divmod`: Calculates the integer quotient and remainder of ``x1`` by ``x2`` element-wise. Examples: >>> jnp.modf(4.8) (Array(0.8000002, dtype=float32, weak_type=True), Array(4., dtype=float32, weak_type=True)) >>> x = jnp.array([-3.4, -5.7, 0.6, 1.5, 2.3]) >>> jnp.modf(x) (Array([-0.4000001 , -0.6999998 , 0.6 , 0.5 , 0.29999995], dtype=float32), Array([-3., -5., 0., 1., 2.], dtype=float32)) modfz0The 'out' argument to jnp.modf is not supported.) rrrerr r_zerorhrm)r%ruwholes r'rrY se4vq!!a "!_ P QQ 399Q<(%(DG <% UE r)ctd|}tj|}tj|tj rt j|Stj|tjrNt jt jt|t jt|St j|dtjS)a*Return a boolean array indicating whether each element of input is finite. JAX implementation of :obj:`numpy.isfinite`. Args: x: input array or scalar. Returns: A boolean array of same shape as ``x`` containing ``True`` where ``x`` is not ``inf``, ``-inf``, or ``NaN``, and ``False`` otherwise. See also: - :func:`jax.numpy.isinf`: Returns a boolean array indicating whether each element of input is either positive or negative infinity. - :func:`jax.numpy.isposinf`: Returns a boolean array indicating whether each element of input is positive infinity. - :func:`jax.numpy.isneginf`: Returns a boolean array indicating whether each element of input is negative infinity. - :func:`jax.numpy.isnan`: Returns a boolean array indicating whether each element of input is not a number (``NaN``). Examples: >>> x = jnp.array([-1, 3, jnp.inf, jnp.nan]) >>> jnp.isfinite(x) Array([ True, True, False, False], dtype=bool) >>> jnp.isfinite(3-4j) Array(True, dtype=bool, weak_type=True) isfiniteTr!)rrr"rSr#rcr is_finiterTrr.rrbrr s r'rr{ s>z1%! ,,q/% ubkk* ==   2 23 ??3==a13==a3I JJ ==D 11r)c td|}tj|}tj|tj rAt jt j|t|tjStj|tjrt j|}t j|}t jt jt j|t|tjt jt j|t|tjSt j|dtj S)aReturn a boolean array indicating whether each element of input is infinite. JAX implementation of :obj:`numpy.isinf`. Args: x: input array or scalar. Returns: A boolean array of same shape as ``x`` containing ``True`` where ``x`` is ``inf`` or ``-inf``, and ``False`` otherwise. See also: - :func:`jax.numpy.isposinf`: Returns a boolean array indicating whether each element of input is positive infinity. - :func:`jax.numpy.isneginf`: Returns a boolean array indicating whether each element of input is negative infinity. - :func:`jax.numpy.isfinite`: Returns a boolean array indicating whether each element of input is finite. - :func:`jax.numpy.isnan`: Returns a boolean array indicating whether each element of input is not a number (``NaN``). Examples: >>> jnp.isinf(jnp.inf) Array(True, dtype=bool) >>> x = jnp.array([2+3j, -jnp.inf, 6, jnp.inf, jnp.nan]) >>> jnp.isinf(x) Array([False, True, False, True, False], dtype=bool) rsFr!)rrr"rSr#rcr rrVr(rrTr.rrrbr)r%r"rXrYs r'rsrs s>w"! ,,q/% ubkk* 66#''!*nQ7 88  2 23 !B !B >>#&&nR.HI&&nR.HI KK ==E 22r)cx| tdtj|}tj|tj r t j|t||Stj|tjr tdt j|dtjS)Nz9The 'out' argument to isneginf/isposinf is not supported.z8isposinf/isneginf are not well defined for complex typesFr!) rerr"rSr#rcr rr(rTrrbr)infinityr%rur"s r' _isposneginfr s_ Y ZZ ,,q/% ubkk* 66!^Ax0 11  2 23 O PP ==E 22r)cPtd|}ttj||S)a4 Return boolean array indicating whether each element of input is positive infinite. JAX implementation of :obj:`numpy.isposinf`. Args: x: input array or scalar. ``complex`` dtype are not supported. Returns: A boolean array of same shape as ``x`` containing ``True`` where ``x`` is ``inf``, and ``False`` otherwise. See also: - :func:`jax.numpy.isinf`: Returns a boolean array indicating whether each element of input is either positive or negative infinity. - :func:`jax.numpy.isneginf`: Returns a boolean array indicating whether each element of input is negative infinity. - :func:`jax.numpy.isfinite`: Returns a boolean array indicating whether each element of input is finite. - :func:`jax.numpy.isnan`: Returns a boolean array indicating whether each element of input is not a number (``NaN``). Examples: >>> jnp.isposinf(5) Array(False, dtype=bool) >>> x = jnp.array([-jnp.inf, 5, jnp.inf, jnp.nan, 1]) >>> jnp.isposinf(x) Array([False, False, True, False, False], dtype=bool) r-rrr#rrts r'r-r- s#>z1%! bffa %%r)cRtd|}ttj ||S)a; Return boolean array indicating whether each element of input is negative infinite. JAX implementation of :obj:`numpy.isneginf`. Args: x: input array or scalar. ``complex`` dtype are not supported. Returns: A boolean array of same shape as ``x`` containing ``True`` where ``x`` is ``-inf``, and ``False`` otherwise. See also: - :func:`jax.numpy.isinf`: Returns a boolean array indicating whether each element of input is either positive or negative infinity. - :func:`jax.numpy.isposinf`: Returns a boolean array indicating whether each element of input is positive infinity. - :func:`jax.numpy.isfinite`: Returns a boolean array indicating whether each element of input is finite. - :func:`jax.numpy.isnan`: Returns a boolean array indicating whether each element of input is not a number (``NaN``). Examples: >>> jnp.isneginf(jnp.inf) Array(False, dtype=bool) >>> x = jnp.array([-jnp.inf, 5, jnp.inf, jnp.nan, 1]) >>> jnp.isneginf(x) Array([ True, False, False, False, False], dtype=bool) isneginfrrts r'rr s%>z1%! rvvgq# &&r)cFtd|}tj||S)aReturns a boolean array indicating whether each element of input is ``NaN``. JAX implementation of :obj:`numpy.isnan`. Args: x: input array or scalar. Returns: A boolean array of same shape as ``x`` containing ``True`` where ``x`` is not a number (i.e. ``NaN``) and ``False`` otherwise. See also: - :func:`jax.numpy.isfinite`: Returns a boolean array indicating whether each element of input is finite. - :func:`jax.numpy.isinf`: Returns a boolean array indicating whether each element of input is either positive or negative infinity. - :func:`jax.numpy.isposinf`: Returns a boolean array indicating whether each element of input is positive infinity. - :func:`jax.numpy.isneginf`: Returns a boolean array indicating whether each element of input is negative infinity. Examples: >>> jnp.isnan(6) Array(False, dtype=bool, weak_type=True) >>> x = jnp.array([2, 1+4j, jnp.inf, jnp.nan]) >>> jnp.isnan(x) Array([False, False, False, True], dtype=bool) r|)rr r4r0s r'r|r|"s >w"! 1r)c td||\}}t||\}}t|d}tt j |||tt j ||t|d|S)atCompute the heaviside step function. JAX implementation of :obj:`numpy.heaviside`. The heaviside step function is defined by: .. math:: \mathrm{heaviside}(x1, x2) = \begin{cases} 0, & x1 < 0\\ x2, & x1 = 0\\ 1, & x1 > 0. \end{cases} Args: x1: input array or scalar. ``complex`` dtype are not supported. x2: scalar or array. Specifies the return values when ``x1`` is ``0``. ``complex`` dtype are not supported. ``x1`` and ``x2`` must either have same shape or broadcast compatible. Returns: An array containing the heaviside step function of ``x1``, promoting to inexact dtype. Examples: >>> x1 = jnp.array([[-2, 0, 3], ... [5, -1, 0], ... [0, 7, -3]]) >>> x2 = jnp.array([2, 0.5, 1]) >>> jnp.heaviside(x1, x2) Array([[0. , 0.5, 1. ], [1. , 0. , 1. ], [2. , 1. , 0. ]], dtype=float32) >>> jnp.heaviside(x1, 0.5) Array([[0. , 0.5, 1. ], [1. , 0. , 0.5], [0.5, 1. , 0. ]], dtype=float32) >>> jnp.heaviside(-3, x2) Array([0., 0., 0.], dtype=float32) heavisiderr:)rrr5rr rr)rrrKs r'rrEsoV KR 0&"b !"b )&"b B $ r4 $svvb$'B):B? AAr)ctd||\}}tj|jtj r t dtj|tj|}}tjt|t|}t||t||}}t|dk(||tjdtjtj |t|dk(tj"||zz}t|t%|tj&|S)a9 Return element-wise hypotenuse for the given legs of a right angle triangle. JAX implementation of :obj:`numpy.hypot`. Args: x1: scalar or array. Specifies one of the legs of right angle triangle. ``complex`` dtype are not supported. x2: scalar or array. Specifies the other leg of right angle triangle. ``complex`` dtype are not supported. ``x1`` and ``x2`` must either have same shape or be broadcast compatible. Returns: An array containing the hypotenuse for the given given legs ``x1`` and ``x2`` of a right angle triangle, promoting to inexact dtype. Note: ``jnp.hypot`` is a more numerically stable way of computing ``jnp.sqrt(x1 ** 2 + x2 **2)``. Examples: >>> jnp.hypot(3, 4) Array(5., dtype=float32, weak_type=True) >>> x1 = jnp.array([[3, -2, 5], ... [9, 1, -4]]) >>> x2 = jnp.array([-5, 6, 8]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.hypot(x1, x2) Array([[ 5.831, 6.325, 9.434], [10.296, 6.083, 8.944]], dtype=float32) hypotzujnp.hypot is not well defined for complex-valued inputs. Please convert to real values first, such as by using abs(x)rr:)rrrSr"r#rTrr rVrr-rrrrrr&rr5r)rridx_infr%s r'rrwsD R 0&"b rxx!3!34 E FF 772; b" NN8B<" 6' 2r?GBOb" R1Wb"sxxCJJswwr6"PQ'SVS\S\]_S`bdCe7f,g(ghhi! Arvv. 22r)c`td|}t|\}tj|dS)aCalculate element-wise reciprocal of the input. JAX implementation of :obj:`numpy.reciprocal`. The reciprocal is calculated by ``1/x``. Args: x: input array or scalar. Returns: An array of same shape as ``x`` containing the reciprocal of each element of ``x``. Note: For integer inputs, ``np.reciprocal`` returns rounded integer output, while ``jnp.reciprocal`` promotes integer inputs to floating point. Examples: >>> jnp.reciprocal(2) Array(0.5, dtype=float32, weak_type=True) >>> jnp.reciprocal(0.) Array(inf, dtype=float32, weak_type=True) >>> x = jnp.array([1, 5., 4.]) >>> jnp.reciprocal(x) Array([1. , 0.2 , 0.25], dtype=float32) reciprocalr)rrr r<r0s r'rrs-:|Q'!a "! B r)c ztd|}t|\}tj|t |d}tj t |t j|}t|t |d|}t|td|tjtj||S)aDCalculate the normalized sinc function. JAX implementation of :func:`numpy.sinc`. The normalized sinc function is given by .. math:: \mathrm{sinc}(x) = \frac{\sin({\pi x})}{\pi x} where ``sinc(0)`` returns the limit value of ``1``. The sinc function is smooth and infinitely differentiable. Args: x : input array; will be promoted to an inexact type. Returns: An array of the same shape as ``x`` containing the result. Examples: >>> x = jnp.array([-1, -0.5, 0, 0.5, 1]) >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.sinc(x) Array([-0. , 0.637, 1. , 0.637, -0. ], dtype=float32) Compare this to the naive approach to computing the function, which is undefined at zero: >>> with jnp.printoptions(precision=3, suppress=True): ... jnp.sin(jnp.pi * x) / (jnp.pi * x) Array([-0. , 0.637, nan, 0.637, -0. ], dtype=float32) JAX defines a custom gradient rule for sinc to allow accurate evaluation of the gradient at zero even for higher-order derivatives: >>> f = jnp.sinc >>> for i in range(1, 6): ... f = jax.grad(f) ... print(f"(d/dx)^{i} f(0.0) = {f(0.0):.2f}") ... (d/dx)^1 f(0.0) = 0.00 (d/dx)^2 f(0.0) = -3.29 (d/dx)^3 f(0.0) = 0.00 (d/dx)^4 f(0.0) = 19.48 (d/dx)^5 f(0.0) = 0.00 sincrr:) rrr rr5rr#rr_sinc_maclaurinr&r{)r%eq_zeropi_x safe_pi_xs r'rrs`vq!!a "! FF1jA& '' Aruu%q )$WjA.5) D1 *I6 88r))r)nondiff_argnumscR|dzr|dzS|dzt|d|dzz|dzz zS)NrFrrr:)r5)kr%s r'rrs< U q5L q5:a"!q&!1QU!;< <rs#$2+,-%*---% K  ZZ  hhhhhh 09?K EI9=157; 6 . 5 A{ T(3(3VT== T:: T+5+5\ )/ )/XT,3,3^T.,.,bT"6"6JT"4"4JT%2%2PT# # LT(6(6VT& & RT  @T  >T  >T' ' TT( ( VT$6$6NT2424jT1414hT-8-8`44nT1414hT. . bT  BT446qJ!>?;@;:q!?!?@=A=:T3C3ClTKK T-.-.`T-2-2`# t - . >T3=3=ltJ$:$:;81<81vtJ$:$:;71<71tT, , ^TAA4T'J'JVtJ$B$BCLDL(uZ%B%BCJDJ(uZ%C%CDLEL(T!I!IH %*T)K)KXT*E*EZT*H*HZT*B*B\T** T,, T** T,, T** T,, T11  6 6FT//dT TggDT #:#:L#E#ELT% % P 3$3$l'!'!T Z Z x T(  wz'<'<=%>%2wz'='=>&?&<T  :T  <TB;K;K|46.6.r##J E E". . b ' ' TT--`T00BT00D  T??8 TJJ<TEE<@T$2$2N'3'3T 3&&D''DTB-A-A`,3,3^T  @4848n T*=+=>>r)