VpfO h ddlmZddlZddlmZmZddlmZddlZddl Z ddl m Z m Z m Z mZmZddlZddlZddlZddlmZddlmZddlmZdd lmZdd lmZdd lmZmZmZmZm Z m!Z!m"Z"ddl#mZ$dd l%m&Z&m'Z'm(Z(m)Z)m*Z*dd l+m,Z-m.Z.m/Z/ej0Z1e$j2Z3ee4ee4dfZ5ddZ6ddZ7ddZ8ddZ9ee e ge fZ:dddd dddd dddd d! dd:Z;d;ZZ>dd@Z?ddAZ@ddCZAeejBdDdE dddGZC dddHZDeejBdDdE dddIZE dddJZFeejBdKdE dddLZG dddMZHeejBdKdE dddNZI dddOZJeejBdKdE dddPddQZK dddPddRZ0eejBdKdE dddPddSZL dddPddTZM dddUZN dddVZOddXZP dddPddYZQeejBdZdE dddd[dd\ZRe ddd`ZSe dd daddcZSe dddeZSe"ejS dddfZSeejBdgdE dddhZT ddddiddmZUeejBdZn dddPddpZVddsZW ddddiddtZXeejBdZn dddPdduZY dddvZZeejBdKn dddwZ[eejBdKn dddxZ\ ddd|Z]eejBdKn ddd}Z^eejBdKn ddd~Z_eejBdZn dddZ`eejBdZn dddZaeejBdZn dddZbeejBdZn dddZceejBdZn dddZdGddeZedZf dddZgegejhejhd Zhegejiejid ZiegejjejhddZjegejkejiddZkegejhejhd dZle"emeddddd dddZne"ejod1dgeejBdn de*dddZoe"ejpd1dgeejBdn de*dddZpddZqe"ejrd1dgeejBdn de*dddZre"ejsd1dgeejBdn de*dddZseejBdn dddZteejBdn dddZudS)) annotationsN)CallableSequence)partial)overloadAnyLiteralProtocolUnion)lax)api)core)dtypes)ufuncs) _broadcast_tocheck_arraylike_complex_elem_typepromote_dtypes_inexactpromote_dtypes_numeric_where implements)Array ArrayLikeDType DTypeLike DeprecatedArg)canonicalize_axismaybe_named_axisNumpyComplexWarningelementrreturnboolct|dr|}tj|pt j|S)N __jax_array__)hasattrr$ris_python_scalarnpisscalar)r s Y/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/numpy/reductions.py _isscalarr*1sE Wo&&&##%%G   ) ) AR[-A-AAarsourceint destinationrctd|tj|}tt j|t|t j|}fdt t j|D}||tj ||S)Nmoveaxisc g|] }|k| Sr3).0ir-s r) z_moveaxis..<s 6 6 6!v++!+++r+) r lax_internalasarray_canonicalize_axisr'ndimrangeinsertr transpose)r,r-r/perms ` r) _moveaxisr?6s*a   1! fbgajj 1 1&"; ;;+ 6 6 6 6U271::&& 6 6 6$++k6""" q$  r+dtyperrctj|tjtjfvrtjdStj|S)Nfloat32)r'r@float16rbfloat16r@s r) _upcast_f16rF@s<Xe__V_555 8I   %r+ctj|tjr tjStj|tjrKtj|jtjtjjkr tjSnitj|tj rJtj|jtjtjjkr tjS|SN) r issubdtyper'bool_int_unsignedintegeriinfobitsuintintegerrEs r)_promote_integer_dtyperQEs ubh'' ;  233 xbhv{33888 [9  ++ xbhv{33888 [ ,r+TF) has_identitypreprocbool_opupcast_f16_for_computationaxisr@outkeepdimsinitialwhere_parallel_reducepromote_integersnamestrnp_funop ReductionOpinit_valrRrS'Callable[[ArrayLike], ArrayLike] | NonerTReductionOp | NonerUrVAxisDTypeLike | NonerWNonerXrYArrayLike | NonerZr[Callable[..., Array] | Noner\c |p|}| td|dt||tj| |t jd| d|d} | |s|t d|dt|tr|ntj |}|r ||n|}t|| \}}| D|sBtj |tfd|Dst d|d | ptj|}| |rt!|}tj|}|r/tj|tjrt)|}n|}t+j||}|tjkr|n|}t1||}|t3|||}||ur"|td |d |||}nt+j||||}| Zt+j| tj |j}|j d krt d |j |||}| rt+j||}t+j|| p|S)NThe 'out' argument to jnp. is not supported.zaxis argument to jnp.z().zreduction operation zO does not have an identity, so to use a where mask one has to specify 'initial'c30K|]}|dkVdS)Nr3)r4dshapes r) z_reduction..ss+00!aA 000000r+z'zero-size array to reduction operation z which has no identityz)Named reductions not implemented for jnp.z()r3z3initial value must be a scalar. Got array of shape )NotImplementedErrorrrcheck_user_dtype_supportedrconcrete_or_error ValueError isinstancerr7r8_reduction_dimsr'rp_allr@rQcanonicalize_dtyperIinexactrFr convert_element_typerJ_reduction_init_valrreduce expand_dims)r,r]r_r`rbrRrSrTrUrVr@rWrXrYrZr[r\pos_dimsdims result_dtypecomputation_dtyperesult initial_arrrps @r) _reductionrUs Mr' _ S4SSS T TT$#E4000 d,MD,M,M,M N N$ _\_f.@ @D@@@ A AA a  AA B BB R V $ $F / _VX . .F !&%*?< @ @@r+c.t|fddS)Nc$t|SrHr9)r5ranks r)z0_canonicalize_axis_allow_named..s'9!T'B'Br+c|SrHr3r]s r)rz0_canonicalize_axis_allow_named..sQUr+)r)xrs `r)_canonicalize_axis_allow_namedrs# !BBBBDUDU V VVr+c|2tttjfdzSt |tjtt fs|f}tfd|D}t|tt|krtd|td|D}t|t|kr||fS||fS)Nc3\K|]&}t|tjV'dSrH)rr'r:)r4rr,s r)rqz"_reduction_dims..sI$$4ArwqzzBB$$$$$$r+zduplicate value in 'axis': c3DK|]}t|t|VdSrH)rvr.)r4rs r)rqz"_reduction_dims..s1EEq*Q2D2DEEEEEEEr+) tupler;r'r:rvndarraylistlensetru)r,rV canon_axiscanon_pos_axiss` r)rwrws \ % ## $ $ & ** dRZ5 6 6 7D$$$$"$$$$$*__C OO,,,, 9499 : ::EEJEEEEE.C OO++ : %% z !!r+ np.ndarrayctjtj|}|dkrtj|dk|Stj|rtj|tjrntj|sZtjtj |rtj |j ntj |j |} tj||S#t$rttj|tjsJtj|tj|}}tj|dkr|j n|j |cYSwxYw)Nr"rrE)rryr@r'arrayisinfrIfloating supports_infisneginffinfominmax OverflowErrorrPsignrM)r,rba_dtyperinfos r)r|r|si  %fl1oo 6 6'  8HqL 0 0 00hxGV.w DDG!'**GxR[5J5J7 W--11#\'226gGGGHG 8HG , , ,, GGG  Wbj 1 1111""FL$9$9$D 8qDHHdhg F F FFFFGs)C??A;E=<E=operandctj5tjdtt j|t jcdddS#1swxYwYdS)Nignore)category)warningscatch_warningsfilterwarningsrr r{r'rJrs r) _cast_to_boolrs  77 H/BCCCC  #GRX 6 6777777777777777777s:AA"Ac,t|dS)Nr)rrs r)_cast_to_numericrs  ( ( ++r+rc4d}tj||dS)Nc|dS tj|S#t$rtd|DcYSwxYw)Nc3lK|]/}t|tr|ntj|V0dSrH)rvr^operatorindex)r4r5s r)rqz7_ensure_optional_axes..force..s?MMa 1c**A11q0A0AMMMMMMr+)rr TypeErrorr)rs r)forcez$_ensure_optional_axes..forcesdy TN ^A   NNN MM1MMM M MMMMNs#AAz+The axis argument must be known statically.)rrt)rrs r)_ensure_optional_axesrs3NNN   1; = ==r+)rVr@rXr\)static_argnamesinlinewherect|dtjtjdt tjd||||||tj|S)NsumrT) rSrTrUrVr@rWrXrYrZr[r\)rr'rr addr bitwise_orpsumr,rVr@rWrXrYrr\s r) _reduce_sumrsH Aubfcgq:JNtUh#E38%5  7 7 77r+c Jt|t|||||||S)a Sum of the elements of the array over a given axis. JAX implementation of :func:`numpy.sum`. Args: a: Input array. axis: int or array, default=None. Axis along which the sum to be computed. If None, the sum is computed along all the axes. dtype: The type of the output array. Default=None. out: Unused by JAX keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. initial: int or array, Default=None. Initial value for the sum. where: int or array, default=None. The elements to be used in the sum. Array should be broadcast compatible to the input. promote_integers : bool, default=True. If True, then integer inputs will be promoted to the widest available integer dtype, following numpy's behavior. If False, the result will have the same dtype as the input. ``promote_integers`` is ignored if ``dtype`` is specified. Returns: An array of the sum along the given axis. See also: - :func:`jax.numpy.prod`: Compute the product of array elements over a given axis. - :func:`jax.numpy.max`: Compute the maximum of array elements over given axis. - :func:`jax.numpy.min`: Compute the minimum of array elements over given axis. Examples: By default, the sum is computed along all the axes. >>> x = jnp.array([[1, 3, 4, 2], ... [5, 2, 6, 3], ... [8, 1, 3, 9]]) >>> jnp.sum(x) Array(47, dtype=int32) If ``axis=1``, the sum is computed along axis 1. >>> jnp.sum(x, axis=1) Array([10, 16, 21], dtype=int32) If ``keepdims=True``, ``ndim`` of the output is equal to that of the input. >>> jnp.sum(x, axis=1, keepdims=True) Array([[10], [16], [21]], dtype=int32) To include only specific elements in the sum, you can use ``where``. >>> where=jnp.array([[0, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.sum(x, axis=1, keepdims=True, where=where) Array([[ 4], [ 9], [12]], dtype=int32) >>> where=jnp.array([[False], ... [False], ... [False]]) >>> jnp.sum(x, axis=0, keepdims=True, where=where) Array([[0, 0, 0, 0]], dtype=int32) rVr@rWrXrYrr\)rrrs r)rrs7J Q24883&u&6 8 8 88r+ct|dtjtjdt tjd|||||||S)NprodrnT) rSrTrUrVr@rWrXrYrZr\)rr'rr mulr bitwise_andrs r) _reduce_prodr&sH Avrw>> x = jnp.array([[1, 3, 4, 2], ... [5, 2, 1, 3], ... [2, 1, 3, 1]]) >>> jnp.prod(x) Array(4320, dtype=int32) If ``axis=1``, product is computed along axis 1. >>> jnp.prod(x, axis=1) Array([24, 30, 6], dtype=int32) If ``keepdims=True``, ``ndim`` of the output is equal to that of the input. >>> jnp.prod(x, axis=1, keepdims=True) Array([[24], [30], [ 6]], dtype=int32) To include only specific elements in the sum, you can use a``where``. >>> where=jnp.array([[1, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.prod(x, axis=1, keepdims=True, where=where) Array([[4], [3], [6]], dtype=int32) >>> where = jnp.array([[False], ... [False], ... [False]]) >>> jnp.prod(x, axis=1, keepdims=True, where=where) Array([[1], [1], [1]], dtype=int32) r)rrrs r)rr1s7L a3D99''7 9 9 99r+rVrXct|dtjtjtj d|||||tj S)NrFrRrVrWrXrYrZr[)rr'rr infpmaxr,rVrWrXrYrs r) _reduce_maxr|sC AubfcgwU3#E38 M M MMr+cFt|t|||||S)aReturn the maximum of the array elements along a given axis. JAX implementation of :func:`numpy.max`. Args: a: Input array. axis: int or array, default=None. Axis along which the maximum to be computed. If None, the maximum is computed along all the axes. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. initial: int or array, default=None. Initial value for the maximum. where: int or array of boolean dtype, default=None. The elements to be used in the maximum. Array should be broadcast compatible to the input. ``initial`` must be specified when ``where`` is used. out: Unused by JAX. Returns: An array of maximum values along the given axis. See also: - :func:`jax.numpy.min`: Compute the minimum of array elements along a given axis. - :func:`jax.numpy.sum`: Compute the sum of array elements along a given axis. - :func:`jax.numpy.prod`: Compute the product of array elements along a given axis. Examples: By default, ``jnp.max`` computes the maximum of elements along all the axes. >>> x = jnp.array([[9, 3, 4, 5], ... [5, 2, 7, 4], ... [8, 1, 3, 6]]) >>> jnp.max(x) Array(9, dtype=int32) If ``axis=1``, the maximum will be computed along axis 1. >>> jnp.max(x, axis=1) Array([9, 7, 8], dtype=int32) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.max(x, axis=1, keepdims=True) Array([[9], [7], [8]], dtype=int32) To include only specific elements in computing the maximum, you can use ``where``. It can either have same dimension as input >>> where=jnp.array([[0, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.max(x, axis=1, keepdims=True, initial=0, where=where) Array([[4], [7], [8]], dtype=int32) or must be broadcast compatible with input. >>> where = jnp.array([[False], ... [False], ... [False]]) >>> jnp.max(x, axis=0, keepdims=True, initial=0, where=where) Array([[0, 0, 0, 0]], dtype=int32) rVrWrXrYr)rrrs r)rrs6L Q2488c&u F F FFr+ct|dtjtjtjd|||||tj S)NrFr)rr'rr rpminrs r) _reduce_minrsA AubfcgrvE3#E38 M M MMr+cFt|t|||||S)aReturn the minimum of array elements along a given axis. JAX implementation of :func:`numpy.min`. Args: a: Input array. axis: int or array, default=None. Axis along which the minimum to be computed. If None, the minimum is computed along all the axes. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. initial: int or array, Default=None. Initial value for the minimum. where: int or array, default=None. The elements to be used in the minimum. Array should be broadcast compatible to the input. ``initial`` must be specified when ``where`` is used. out: Unused by JAX. Returns: An array of minimum values along the given axis. See also: - :func:`jax.numpy.max`: Compute the maximum of array elements along a given axis. - :func:`jax.numpy.sum`: Compute the sum of array elements along a given axis. - :func:`jax.numpy.prod`: Compute the product of array elements along a given axis. Examples: By default, the minimum is computed along all the axes. >>> x = jnp.array([[2, 5, 1, 6], ... [3, -7, -2, 4], ... [8, -4, 1, -3]]) >>> jnp.min(x) Array(-7, dtype=int32) If ``axis=1``, the minimum is computed along axis 1. >>> jnp.min(x, axis=1) Array([ 1, -7, -4], dtype=int32) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.min(x, axis=1, keepdims=True) Array([[ 1], [-7], [-4]], dtype=int32) To include only specific elements in computing the minimum, you can use ``where``. ``where`` can either have same dimension as input. >>> where=jnp.array([[1, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.min(x, axis=1, keepdims=True, initial=0, where=where) Array([[ 0], [-2], [-4]], dtype=int32) or must be broadcast compatible with input. >>> where = jnp.array([[False], ... [False], ... [False]]) >>> jnp.min(x, axis=0, keepdims=True, initial=0, where=where) Array([[0, 0, 0, 0]], dtype=int32) r)rrrs r)rrs6J Q2488c&u F F FFr+rc ft|dtjtjdt |||| S)NallTrSrVrWrXrZ)rr'rr rrr,rVrWrXrs r) _reduce_allrs8 Aubfcot]3% I I IIr+cDt|t||||S)aTest whether all array elements along a given axis evaluate to True. JAX implementation of :func:`numpy.all`. Args: a: Input array. axis: int or array, default=None. Axis along which to be tested. If None, tests along all the axes. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. where: int or array of boolean dtype, default=None. The elements to be used in the test. Array should be broadcast compatible to the input. out: Unused by JAX. Returns: An array of boolean values. Examples: By default, ``jnp.all`` tests for True values along all the axes. >>> x = jnp.array([[True, True, True, False], ... [True, False, True, False], ... [True, True, False, False]]) >>> jnp.all(x) Array(False, dtype=bool) If ``axis=0``, tests for True values along axis 0. >>> jnp.all(x, axis=0) Array([ True, False, False, False], dtype=bool) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.all(x, axis=0, keepdims=True) Array([[ True, False, False, False]], dtype=bool) To include specific elements in testing for True values, you can use a``where``. >>> where=jnp.array([[1, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.all(x, axis=0, keepdims=True, where=where) Array([[ True, True, False, False]], dtype=bool) rVrWrXr)rrrs r)rr&0\ Q2488c&e 5 5 55r+c ft|dtjtjdt |||| S)NanyFr)rr'rr rrrs r) _reduce_anyrWs8 Aubfcne]3% I I IIr+cDt|t||||S)aTest whether any of the array elements along a given axis evaluate to True. JAX implementation of :func:`numpy.any`. Args: a: Input array. axis: int or array, default=None. Axis along which to be tested. If None, tests along all the axes. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. where: int or array of boolean dtype, default=None. The elements to be used in the test. Array should be broadcast compatible to the input. out: Unused by JAX. Returns: An array of boolean values. Examples: By default, ``jnp.any`` tests along all the axes. >>> x = jnp.array([[True, True, True, False], ... [True, False, True, False], ... [True, True, False, False]]) >>> jnp.any(x) Array(True, dtype=bool) If ``axis=0``, tests along axis 0. >>> jnp.any(x, axis=0) Array([ True, True, True, False], dtype=bool) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.any(x, axis=0, keepdims=True) Array([[ True, True, True, False]], dtype=bool) To include specific elements in testing for True values, you can use a``where``. >>> where=jnp.array([[1, 0, 1, 0], ... [0, 1, 0, 1], ... [1, 0, 1, 0]], dtype=bool) >>> jnp.any(x, axis=0, keepdims=True, where=where) Array([[ True, False, True, False]], dtype=bool) r)rrrs r)rr^rr+c,t||||||S)zAlias of :func:`jax.numpy.min`.r)rrs r)aminr( QTsXE + + ++r+c,t||||||S)zAlias of :func:`jax.numpy.max`.r)rrs r)amaxrrr+int | Sequence[int]ct|ttfs|f}n|}d}tj||D]}|t |fddz}|S)Nrnc|SrHr3)r5a_shapes r)rz_axis_size..s '!*r+c,tjd|S)Nrn)r rrs r)rz_axis_size..s38AtCTCTr+)rvrrr'rpr)r,rVaxis_seqsizers @r) _axis_sizersv D5$- ( (#gHHH $ HQKK' VVa Q 4 4 4 46T6T U UUDD +r+cFt|t|||||S)a2Return the mean of array elements along a given axis. JAX implementation of :func:`numpy.mean`. Args: a: input array. axis: optional, int or sequence of ints, default=None. Axis along which the mean to be computed. If None, mean is computed along all the axes. dtype: The type of the output array. Default=None. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. where: optional, boolean array, default=None. The elements to be used in the mean. Array should be broadcast compatible to the input. out: Unused by JAX. Returns: An array of the mean along the given axis. See also: - :func:`jax.numpy.sum`: Compute the sum of array elements over a given axis. - :func:`jax.numpy.max`: Compute the maximum of array elements over given axis. - :func:`jax.numpy.min`: Compute the minimum of array elements over given axis. Examples: By default, the mean is computed along all the axes. >>> x = jnp.array([[1, 3, 4, 2], ... [5, 2, 6, 3], ... [8, 1, 2, 9]]) >>> jnp.mean(x) Array(3.8333335, dtype=float32) If ``axis=1``, the mean is computed along axis 1. >>> jnp.mean(x, axis=1) Array([2.5, 4. , 5. ], dtype=float32) If ``keepdims=True``, ``ndim`` of the output is equal to that of the input. >>> jnp.mean(x, axis=1, keepdims=True) Array([[2.5], [4. ], [5. ]], dtype=float32) To use only specific elements of ``x`` to compute the mean, you can use ``where``. >>> where = jnp.array([[1, 0, 1, 0], ... [0, 1, 0, 1], ... [1, 1, 0, 1]], dtype=bool) >>> jnp.mean(x, axis=1, keepdims=True, where=where) Array([[2.5], [2.5], [6. ]], dtype=float32) r)_meanr)r,rVr@rWrXrs r)meanrs2t q'--uc8   r+rVr@rX)rUrc td||td|)tjtj|d}n)tj|dtj|}|r/tj|tj rt|}n|}|L|'tj tj |} nVtj t||} n3tt!|tj||||} t%jt|||||t%j| ||S)Nrz0The 'out' argument to jnp.mean is not supported.T canonicalizer@rXr@rXr)rrrrto_inexact_dtyper@rsryrIr'rzrFrdimension_as_valuerrrrrpr divr{astype) r,rVr@rWrXrUrrr normalizers r)rrsZ &!_ P Q QQ ]*6<+M+M+MNNLL %eV444,U33L%F$5lBJ$O$O%#L11$ ] |*271::66jj*:a+>+>??jj]5"(1++66ET\]]]J  !T*XUKKK z+<==   F<r+weightsreturnedLiteral[False]cdSrHr3r,rVrrrXs r)averagersPSPSr+)rX Literal[True]cdSrHr3rs r)rr sGJsr+Array | tuple[Array, Array]cdSrHr3rs r)rr s\_\_r+cBt|t||||SrH)_averagerrs r)rrs# !*400'8X N NNr+)rVrrXc4 |tdt\t||}|5tjdt jj|j}nt|tr5tj |tj fd|D}ntj |t jj|}ntd|t|\}tj}t!| tj|}|nAt|trt fd|D}nt#| }||krt!|dkrt%d|t%d t|trt%d t j|d ||st%d t)| dz d z|z}t+|d|}t-|||}t-|z|||z }|r)|j|jkrt)||j}||fS|S)Nrrr3rEc3VK|]#}tjj|V$dSrH)rrrp)r4ror,s r)rqz_average..s60c0cYZ1HQR1T1T0c0c0c0c0c0cr+c38K|]}t|VdSrHr)r4roa_ndims r)rqz_average..-s.??Q%a00??????r+rnz81D weights expected when shapes of a and weights differ.z;Axis must be specified when shapes of a and weights differ.z8Single axis expected when shapes of a and weights differrz5Length of weights not compatible with specified axis.)rn)rrrr fullrrrr@rvr full_likemathrrpr'rr9rudefinitely_equalrr?r) r,rVrrrXavg weights_sumr weights_shapers ` @r)r r s _Iq!!!  " "BA qth / / /C |HR!8!@!@ RRRkk D% OM#ty0c0c0c0c^b0c0c0c'c'cddkkM#t'>qwt}'M'MNNkkIq'***'733JAwhqkkG \\FHW%%M | D% . ????$??? ? ?dd f - -d- ]  q +,, , +,, , dE " "<STTT$]1%5wt}EE<;<< <g d':]'JKKg'2t,,ggD8<<>> x = jnp.array([[1, 3, 4, 2], ... [5, 2, 6, 3], ... [8, 4, 2, 9]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.var(x) Array(5.74, dtype=float32) If ``axis=1``, variance is computed along axis 1. >>> jnp.var(x, axis=1) Array([1.25 , 2.5 , 8.1875], dtype=float32) To preserve the dimensions of input, you can set ``keepdims=True``. >>> jnp.var(x, axis=1, keepdims=True) Array([[1.25 ], [2.5 ], [8.1875]], dtype=float32) If ``ddof=1``: >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.var(x, axis=1, keepdims=True, ddof=1)) [[ 1.67] [ 3.33] [10.92]] To include specific elements of the array to compute variance, you can use ``where``. >>> where = jnp.array([[1, 0, 1, 0], ... [0, 1, 1, 0], ... [1, 1, 1, 0]], dtype=bool) >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.var(x, axis=1, keepdims=True, where=where)) [[2.25] [4. ] [6.22]] Nr5ddof and correction can't be provided simultaneously.r)rvr.ru_varrr,rVr@rWrrXrrs r)varr!LskXJJ dC NDAII L M MM a&t,,eS*h   r+r int | floatctd|tj|d|tdt tj||\}}t j||}t|||d|}tj ||} tj |tjrAtjtj| tj| } | j}ntj| } |a|'t'jtj|} n"t'jt-||} tj| |} n3t1t3|tj||||} tj | tj||} t1| ||||} tj| | |} t9jd5t=| dk| tj} dddn #1swxYwY| S)Nr!z/The 'out' argument to jnp.var is not supported.TrrFr) rrrsrr_var_promote_typesr@r7r8rrr subrIr'complexfloatingrealrconjsquarerrrrr{rrrprjax debug_nansrnan) r,rVr@rWrrXrra_meancenteredrrs r)rrsW%#E5111_ O P PP/ QGGU1$$%677! 404u M M M& WQ  ( ("*<==$x#(8*<*<==>>H z(##H ] |*271::66jj*:a+>+>??j)*6GHHJJ]5"(1++66,xAAAJwz3#;JHY#Z#Z[[* x%6QV W W W& 76: & & - -e 4 4& ~e44 JNFBF 3 3F444444444444444 -s. II!Irtuple[DType, DType]c~|rRtj|tjs0tj|tjrd}t ||}nGtj|tjstj|}|}nt|}|}t|tj |fS)Na jax.numpy.var does not yet support real dtype parameters when computing the variance of an array of complex values. The semantics of numpy.var seem unclear in this case. Please comment on https://github.com/google/jax/issues/2283 if this behavior is important to you.) rrIr'r'rurzrrrFr@)rr@msgrs r)r%r%s "  eR%7 8 8'2#566!c sOO  Wbj 1 1"%g..e ))e! & ' '% 88r+c ||}n*t|tr|dkrtdt|t ||||||S)a: Compute the standard deviation along a given axis. JAX implementation of :func:`numpy.std`. Args: a: input array. axis: optional, int or sequence of ints, default=None. Axis along which the standard deviation is computed. If None, standard deviaiton is computed along all the axes. dtype: The type of the output array. Default=None. ddof: int, default=0. Degrees of freedom. The divisor in the standard deviation computation is ``N-ddof``, ``N`` is number of elements along given axis. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. where: optional, boolean array, default=None. The elements to be used in the standard deviation. Array should be broadcast compatible to the input. correction: int or float, default=None. Alternative name for ``ddof``. Both ddof and correction can't be provided simultaneously. out: Unused by JAX. Returns: An array of the standard deviation along the given axis. See also: - :func:`jax.numpy.var`: Compute the variance of array elements over given axis. - :func:`jax.numpy.mean`: Compute the mean of array elements over a given axis. - :func:`jax.numpy.nanvar`: Compute the variance along a given axis, ignoring NaNs values. - :func:`jax.numpy.nanstd`: Computed the standard deviation of a given axis, ignoring NaN values. Examples: By default, ``jnp.std`` computes the standard deviation along all axes. >>> x = jnp.array([[1, 3, 4, 2], ... [4, 2, 5, 3], ... [5, 4, 2, 3]]) >>> with jnp.printoptions(precision=2, suppress=True): ... jnp.std(x) Array(1.21, dtype=float32) If ``axis=0``, computes along axis 0. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.std(x, axis=0)) [1.7 0.82 1.25 0.47] To preserve the dimensions of input, you can set ``keepdims=True``. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.std(x, axis=0, keepdims=True)) [[1.7 0.82 1.25 0.47]] If ``ddof=1``: >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.std(x, axis=0, keepdims=True, ddof=1)) [[2.08 1. 1.53 0.58]] To include specific elements of the array to compute standard deviation, you can use ``where``. >>> where = jnp.array([[1, 0, 1, 0], ... [0, 1, 0, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.std(x, axis=0, keepdims=True, where=where) Array([[2., 1., 1., 0.]], dtype=float32) Nrrr)rvr.ru_stdrr s r)stdr5skPJJ dC NDAII L M MM a&t,,eS*h   r+c "td|tj|d|1tj|tjst d||tdtj t||||||S)Nr5z/dtype argument to jnp.std must be inexact; got z/The 'out' argument to jnp.std is not supported.)rVr@rrXr) rrrsrIr'rzrurrr sqrtr!)r,rVr@rWrrXrs r)r4r4's%#E5111 v0 CC NuNN O OO_ O P PP #ad%JQYafggg h hhr+c@t|t|||S)aReturn the peak-to-peak range along a given axis. JAX implementation of :func:`numpy.ptp`. Args: a: input array. axis: optional, int or sequence of ints, default=None. Axis along which the range is computed. If None, the range is computed on the flattened array. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. out: Unused by JAX. Returns: An array with the range of elements along specified axis of input. Examples: By default, ``jnp.ptp`` computes the range along all axes. >>> x = jnp.array([[1, 3, 5, 2], ... [4, 6, 8, 1], ... [7, 9, 3, 4]]) >>> jnp.ptp(x) Array(8, dtype=int32) If ``axis=1``, computes the range along axis 1. >>> jnp.ptp(x, axis=1) Array([4, 7, 6], dtype=int32) To preserve the dimensions of input, you can set ``keepdims=True``. >>> jnp.ptp(x, axis=1, keepdims=True) Array([[4], [7], [6]], dtype=int32) )_ptpr)r,rVrWrXs r)ptpr:4s"L a&t,,c8 < <>> x = jnp.array([[1, 0, 0, 0], ... [0, 0, 1, 0], ... [1, 1, 1, 0]]) >>> jnp.count_nonzero(x) Array(5, dtype=int32) If ``axis=1``, counts along axis 1. >>> jnp.count_nonzero(x, axis=1) Array([1, 1, 3], dtype=int32) To preserve the dimensions of input, you can set ``keepdims=True``. >>> jnp.count_nonzero(x, axis=1, keepdims=True) Array([[1], [1], [3]], dtype=int32) count_nonzerorr)rrr ne _lax_constrryr.)r,rVrXs r)r>r>gsZL/1%%% SVAz!Q'' ( (t,S11H F F FFr+ jnp_reductionCallable[..., Array]nan_if_all_nanc t||tjtj|tjs ||f||d|S|t tj|t|||f||d|}|rKt ttj|||t|tj |S|S)Nr) rrrIr@r'rzrr7_isnanr|rr@r-) r,r]rArbrCrVrXkwargsrWs r)_nan_reductionrGs$  6<??BJ 7 7D = C C CF C CC f\0335HH5U5UWXYY >( > >6< > ># #l)!,,4(KKKQ'' . .. Jr+c Vt|dttj|du||||| S)aJ Return the minimum of the array elements along a given axis, ignoring NaNs. JAX implementation of :func:`numpy.nanmin`. Args: a: Input array. axis: int or sequence of ints, default=None. Axis along which the minimum is computed. If None, the minimum is computed along the flattened array. keepdims: bool, default=False. If True, reduced axes are left in the result with size 1. initial: int or array, default=None. Initial value for the minimum. where: array of boolean dtype, default=None. The elements to be used in the minimum. Array should be broadcast compatible to the input. ``initial`` must be specified when ``where`` is used. out: Unused by JAX. Returns: An array of minimum values along the given axis, ignoring NaNs. If all values are NaNs along the given axis, returns ``nan``. See also: - :func:`jax.numpy.nanmax`: Compute the maximum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nansum`: Compute the sum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanprod`: Compute the product of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanmean`: Compute the mean of array elements along a given axis, ignoring NaNs. Examples: By default, ``jnp.nanmin`` computes the minimum of elements along the flattened array. >>> nan = jnp.nan >>> x = jnp.array([[1, nan, 4, 5], ... [nan, -2, nan, -4], ... [2, 1, 3, nan]]) >>> jnp.nanmin(x) Array(-4., dtype=float32) If ``axis=1``, the maximum will be computed along axis 1. >>> jnp.nanmin(x, axis=1) Array([ 1., -4., 1.], dtype=float32) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.nanmin(x, axis=1, keepdims=True) Array([[ 1.], [-4.], [ 1.]], dtype=float32) To include only specific elements in computing the maximum, you can use ``where``. It can either have same dimension as input >>> where=jnp.array([[0, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.nanmin(x, axis=1, keepdims=True, initial=0, where=where) Array([[ 0.], [-4.], [ 0.]], dtype=float32) or must be broadcast compatible with input. >>> where = jnp.array([[False], ... [True], ... [False]]) >>> jnp.nanmin(x, axis=0, keepdims=True, initial=0, where=where) Array([[ 0., -2., 0., -4.]], dtype=float32) nanminNrCrVrWrXrYr)rGrr'rrs r)rIrIs8Z 8S"&D!sX 'u 6 6 66r+c Xt|dttj |du||||| S)aC Return the maximum of the array elements along a given axis, ignoring NaNs. JAX implementation of :func:`numpy.nanmax`. Args: a: Input array. axis: int or sequence of ints, default=None. Axis along which the maximum is computed. If None, the maximum is computed along the flattened array. keepdims: bool, default=False. If True, reduced axes are left in the result with size 1. initial: int or array, default=None. Initial value for the maximum. where: array of boolean dtype, default=None. The elements to be used in the maximum. Array should be broadcast compatible to the input. ``initial`` must be specified when ``where`` is used. out: Unused by JAX. Returns: An array of maximum values along the given axis, ignoring NaNs. If all values are NaNs along the given axis, returns ``nan``. See also: - :func:`jax.numpy.nanmin`: Compute the minimum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nansum`: Compute the sum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanprod`: Compute the product of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanmean`: Compute the mean of array elements along a given axis, ignoring NaNs. Examples: By default, ``jnp.nanmax`` computes the maximum of elements along the flattened array. >>> nan = jnp.nan >>> x = jnp.array([[8, nan, 4, 6], ... [nan, -2, nan, -4], ... [-2, 1, 7, nan]]) >>> jnp.nanmax(x) Array(8., dtype=float32) If ``axis=1``, the maximum will be computed along axis 1. >>> jnp.nanmax(x, axis=1) Array([ 8., -2., 7.], dtype=float32) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.nanmax(x, axis=1, keepdims=True) Array([[ 8.], [-2.], [ 7.]], dtype=float32) To include only specific elements in computing the maximum, you can use ``where``. It can either have same dimension as input >>> where=jnp.array([[0, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.nanmax(x, axis=1, keepdims=True, initial=0, where=where) Array([[4.], [0.], [7.]], dtype=float32) or must be broadcast compatible with input. >>> where = jnp.array([[True], ... [False], ... [False]]) >>> jnp.nanmax(x, axis=0, keepdims=True, initial=0, where=where) Array([[8., 0., 4., 6.]], dtype=float32) nanmaxNrJ)rGrr'rrs r)rLrLs:Z 8S26''T/!sX 'u 6 6 66r+c jtj|dt|dtdd|||||| S)a Return the sum of the array elements along a given axis, ignoring NaNs. JAX implementation of :func:`numpy.nansum`. Args: a: Input array. axis: int or sequence of ints, default=None. Axis along which the sum is computed. If None, the sum is computed along the flattened array. dtype: The type of the output array. Default=None. keepdims: bool, default=False. If True, reduced axes are left in the result with size 1. initial: int or array, default=None. Initial value for the sum. where: array of boolean dtype, default=None. The elements to be used in the sum. Array should be broadcast compatible to the input. out: Unused by JAX. Returns: An array containing the sum of array elements along the given axis, ignoring NaNs. If all elements along the given axis are NaNs, returns 0. See also: - :func:`jax.numpy.nanmin`: Compute the minimum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanmax`: Compute the maximum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanprod`: Compute the product of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanmean`: Compute the mean of array elements along a given axis, ignoring NaNs. Examples: By default, ``jnp.nansum`` computes the sum of elements along the flattened array. >>> nan = jnp.nan >>> x = jnp.array([[3, nan, 4, 5], ... [nan, -2, nan, 7], ... [2, 1, 6, nan]]) >>> jnp.nansum(x) Array(26., dtype=float32) If ``axis=1``, the sum will be computed along axis 1. >>> jnp.nansum(x, axis=1) Array([12., 5., 9.], dtype=float32) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.nansum(x, axis=1, keepdims=True) Array([[12.], [ 5.], [ 9.]], dtype=float32) To include only specific elements in computing the sum, you can use ``where``. >>> where=jnp.array([[1, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.nansum(x, axis=1, keepdims=True, where=where) Array([[7.], [7.], [9.]], dtype=float32) If ``where`` is ``False`` at all elements, ``jnp.nansum`` returns 0 along the given axis. >>> where = jnp.array([[False], ... [False], ... [False]]) >>> jnp.nansum(x, axis=0, keepdims=True, where=where) Array([[0., 0., 0., 0.]], dtype=float32) nanprodnansumrFrCrVr@rWrXrYr)rrsrGrr,rVr@rWrXrYrs r)rOrOFsGZ #E9555 8S!E!C( 'u 6 6 66r+c jtj|dt|dtdd|||||| S)aE Return the product of the array elements along a given axis, ignoring NaNs. JAX implementation of :func:`numpy.nanprod`. Args: a: Input array. axis: int or sequence of ints, default=None. Axis along which the product is computed. If None, the product is computed along the flattened array. dtype: The type of the output array. Default=None. keepdims: bool, default=False. If True, reduced axes are left in the result with size 1. initial: int or array, default=None. Initial value for the product. where: array of boolean dtype, default=None. The elements to be used in the product. Array should be broadcast compatible to the input. out: Unused by JAX. Returns: An array containing the product of array elements along the given axis, ignoring NaNs. If all elements along the given axis are NaNs, returns 1. See also: - :func:`jax.numpy.nanmin`: Compute the minimum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanmax`: Compute the maximum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nansum`: Compute the sum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanmean`: Compute the mean of array elements along a given axis, ignoring NaNs. Examples: By default, ``jnp.nanprod`` computes the product of elements along the flattened array. >>> nan = jnp.nan >>> x = jnp.array([[nan, 3, 4, nan], ... [5, nan, 1, 3], ... [2, 1, nan, 1]]) >>> jnp.nanprod(x) Array(360., dtype=float32) If ``axis=1``, the product will be computed along axis 1. >>> jnp.nanprod(x, axis=1) Array([12., 15., 2.], dtype=float32) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.nanprod(x, axis=1, keepdims=True) Array([[12.], [15.], [ 2.]], dtype=float32) To include only specific elements in computing the maximum, you can use ``where``. >>> where=jnp.array([[1, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 1, 0]], dtype=bool) >>> jnp.nanprod(x, axis=1, keepdims=True, where=where) Array([[4.], [3.], [2.]], dtype=float32) If ``where`` is ``False`` at all elements, ``jnp.nanprod`` returns 1 along the given axis. >>> where = jnp.array([[False], ... [False], ... [False]]) >>> jnp.nanprod(x, axis=0, keepdims=True, where=where) Array([[1., 1., 1., 1.]], dtype=float32) rNrnFrP)rrsrGrrQs r)rNrNsGZ #E9555 9dAe!C( 'u 6 6 66r+c td||tdtjtj|t js1tjtj|t jrt||||||S|)tj tj|d}n)tj |dtj |}tj tj|}t|||||}t!jt%||||| |}|S) a Return the mean of the array elements along a given axis, ignoring NaNs. JAX implementation of :func:`numpy.nanmean`. Args: a: Input array. axis: int or sequence of ints, default=None. Axis along which the mean is computed. If None, the mean is computed along the flattened array. dtype: The type of the output array. Default=None. keepdims: bool, default=False. If True, reduced axes are left in the result with size 1. where: array of boolean dtype, default=None. The elements to be used in computing mean. Array should be broadcast compatible to the input. out: Unused by JAX. Returns: An array containing the mean of array elements along the given axis, ignoring NaNs. If all elements along the given axis are NaNs, returns ``nan``. See also: - :func:`jax.numpy.nanmin`: Compute the minimum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanmax`: Compute the maximum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nansum`: Compute the sum of array elements along a given axis, ignoring NaNs. - :func:`jax.numpy.nanprod`: Compute the product of array elements along a given axis, ignoring NaNs. Examples: By default, ``jnp.nanmean`` computes the mean of elements along the flattened array. >>> nan = jnp.nan >>> x = jnp.array([[2, nan, 4, 3], ... [nan, -2, nan, 9], ... [4, -7, 6, nan]]) >>> jnp.nanmean(x) Array(2.375, dtype=float32) If ``axis=1``, mean will be computed along axis 1. >>> jnp.nanmean(x, axis=1) Array([3. , 3.5, 1. ], dtype=float32) If ``keepdims=True``, ``ndim`` of the output will be same of that of the input. >>> jnp.nanmean(x, axis=1, keepdims=True) Array([[3. ], [3.5], [1. ]], dtype=float32) ``where`` can be used to include only specific elements in computing the mean. >>> where = jnp.array([[1, 0, 1, 0], ... [0, 0, 1, 1], ... [1, 1, 0, 1]], dtype=bool) >>> jnp.nanmean(x, axis=1, keepdims=True, where=where) Array([[ 3. ], [ 9. ], [-1.5]], dtype=float32) If ``where`` is ``False`` at all elements, ``jnp.nanmean`` returns ``nan`` along the given axis. >>> where = jnp.array([[False], ... [False], ... [False]]) >>> jnp.nanmean(x, axis=0, keepdims=True, where=where) Array([[nan, nan, nan, nan]], dtype=float32) nanmeanNz3The 'out' argument to jnp.nanmean is not supported.rTrr)rVr@rXrr)rrrrrIr@r'rJrPrrrsryr7 bitwise_notrErr rrO) r,rVr@rWrXrnan_maskrtds r)rTrTs)V)Q_ S T TT v|A11>> nan = jnp.nan >>> x = jnp.array([[1, nan, 4, 3], ... [nan, 2, nan, 9], ... [4, 8, 6, nan]]) >>> jnp.nanvar(x) Array(6.984375, dtype=float32) If ``axis=1``, variance is computed along axis 1. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.nanvar(x, axis=1)) [ 1.56 12.25 2.67] To preserve the dimensions of input, you can set ``keepdims=True``. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.nanvar(x, axis=1, keepdims=True)) [[ 1.56] [12.25] [ 2.67]] If ``ddof=1``: >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.nanvar(x, axis=1, keepdims=True, ddof=1)) [[ 2.33] [24.5 ] [ 4. ]] To include specific elements of the array to compute variance, you can use ``where``. >>> where = jnp.array([[1, 0, 1, 0], ... [0, 1, 1, 0], ... [1, 1, 0, 1]], dtype=bool) >>> jnp.nanvar(x, axis=1, keepdims=True, where=where) Array([[2.25], [0. ], [4. ]], dtype=float32) nanvarNz2The 'out' argument to jnp.nanvar is not supported.Trr)rVrXr)rXrrn)rrrsrrr%r@r7r8rrTrrEr r&rIr'r'r(rr)r*rrUle_zeror-rr{)r,rVr@rWrrXrrr.r/rnormalizer_maskrdivisors r)rYrYGsX(A#E8444_ R S SS/ QGGU1$$%677! 1d"3d% P P P& L'**Aswq&/A/A B B( x~r'9::$x#(8*<*<==>>HHz(##H<+L,?,B,BCCxu>>>*D *F:|'9*'E'EFF/ x > > >& /266 2 2& ?Az 2 2' 7633GV\JJ K K& !&% 0 00r+c td|tj|d|tdt jt ||||||S)ay Compute the standard deviation along a given axis, ignoring NaNs. JAX implementation of :func:`numpy.nanstd`. Args: a: input array. axis: optional, int or sequence of ints, default=None. Axis along which the standard deviation is computed. If None, standard deviaiton is computed along flattened array. dtype: The type of the output array. Default=None. ddof: int, default=0. Degrees of freedom. The divisor in the standard deviation computation is ``N-ddof``, ``N`` is number of elements along given axis. keepdims: bool, default=False. If true, reduced axes are left in the result with size 1. where: optional, boolean array, default=None. The elements to be used in the standard deviation. Array should be broadcast compatible to the input. out: Unused by JAX. Returns: An array containing the standard deviation of array elements along the given axis. If all elements along the given axis are NaNs, returns ``nan``. See also: - :func:`jax.numpy.nanmean`: Compute the mean of array elements over a given axis, ignoring NaNs. - :func:`jax.numpy.nanvar`: Compute the variance along the given axis, ignoring NaNs values. - :func:`jax.numpy.std`: Computed the standard deviation along the given axis. Examples: By default, ``jnp.nanstd`` computes the standard deviation along flattened array. >>> nan = jnp.nan >>> x = jnp.array([[3, nan, 4, 5], ... [nan, 2, nan, 7], ... [2, 1, 6, nan]]) >>> jnp.nanstd(x) Array(1.9843135, dtype=float32) If ``axis=0``, computes standard deviation along axis 0. >>> jnp.nanstd(x, axis=0) Array([0.5, 0.5, 1. , 1. ], dtype=float32) To preserve the dimensions of input, you can set ``keepdims=True``. >>> jnp.nanstd(x, axis=0, keepdims=True) Array([[0.5, 0.5, 1. , 1. ]], dtype=float32) If ``ddof=1``: >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.nanstd(x, axis=0, keepdims=True, ddof=1)) [[0.71 0.71 1.41 1.41]] To include specific elements of the array to compute standard deviation, you can use ``where``. >>> where=jnp.array([[1, 0, 1, 0], ... [0, 1, 0, 1], ... [1, 1, 0, 1]], dtype=bool) >>> jnp.nanstd(x, axis=0, keepdims=True, where=where) Array([[0.5, 0.5, 0. , 0. ]], dtype=float32) nanstdNz2The 'out' argument to jnp.nanstd is not supported.)rVr@rrXr)rrrsrrr r7rY)r,rVr@rWrrXrs r)r_r_sbH(A#E8444_ R S SS &UX]^^^ _ __r+ceZdZ d dd ZdS)CumulativeReductionNr,rrVrer@rfrWrgr!rcdSrHr3)selfr,rVr@rWs r)__call__zCumulativeReduction.__call__sKN3r+NNN r,rrVrer@rfrWrgr!r)__name__ __module__ __qualname__rdr3r+r)raras:04;?OOOOOOOr+razz Unlike the numpy counterpart, when ``dtype`` is not specified the output dtype will always match the dtype of the input. np_reduction reductionfill_nan fill_valuectdgt ddfd }ttjd  ddfd |S)NrW) skip_paramslax_descriptionr,rrVrer@rfrgr!rc:|t|||SrH)r)r,rVr@rW_cumulative_reductions r)cumulative_reductionz8_make_cumulative_reduction..cumulative_reductions% ! $9$$?$? L LLr+rVr@r"cpt j||td jdtj| j|t |r(t j|tj |f}|d}ttj |}t|}t||}r1ttj|t#| |}tj|p|}| stj|tjrt+|}tj|}t j||} ||}tj|tjrt j|tj}|S)Nrkrlr)rrgrrrrsr*r reshaper'rrrprr9rr7rEr@r@rIrJrQryr{) r,rVr@rWrnum_dims result_typerrlrmrjr\rks r)rrz9_make_cumulative_reduction.._cumulative_reduction sL)1---  !5\=R!5!5!5 6 66 %e\-BCCC |y||| +a"'!** ' 'a | d28A;;G7||H dH - -DG $Q''Az)B)BA F Fa#\%*155K })}V->{BH-U-U}*;77k+K88K  K00A Yq$  F)):'99f Mr+rerf)rCUML_REDUCTION_LAX_DESCRIPTIONrr jit)rjrkrlrmr\rsrrs````` @r)_make_cumulative_reductionr{sl8:::6:GKMMMMMM::M 37$56667;HL76B r+)rl)rlrmrn)rlr\cumulative_sum)rVr@include_initial int | Noner}ctd|tj|}|jdkrt d|%d}|jdkrt d|jdt ||j}t j|t|||}|rKt|j }d||<tj tj |d|j |g| }|S) Nr|rzhThe input must be non-scalar to take a cumulative sum, however a scalar value or scalar array was given.rnzThe input array has rank zo, however axis was not set to an explicit value. The axis argument is only optional for one-dimensional arrays.rtrE dimension)rr7r8r:rur9rrs_cumsum_with_promotionrrp concatenaterr@)rrVr@r}rW zeros_shapes r)r|r|;s "A&&&1!Vq[[ 0   \ Dvzz  AF      D!& ) )$#E***qt5999#qw--KK  "asy9993?   C *r+overwrite_input)ro)rVr interpolationrXmethodlinear)rqint | tuple[int, ...] | NonerrDeprecatedArg | strc$td|||s|d}t|t|tst jdt d|}ttj |tj ||||dS)NquantilezGjax.numpy.quantile does not support overwrite_input=True or out != NonezOThe interpolation= argument to 'quantile' is deprecated. Use 'method=' instead.r stacklevelF rrurvrrwarnDeprecationWarning _quantiler7r8 r,rrVrWrrrXrr2s r)rr]s *a### C S// M= 1 1 M+,>1NNNN F <'**L,@,C,CT6S[]b c ccr+c$td|||s|d}t|t|tst jdt d|}ttj |tj ||||dS)N nanquantilezJjax.numpy.nanquantile does not support overwrite_input=True or out != NonezRThe interpolation= argument to 'nanquantile' is deprecated. Use 'method=' instead.rrTrrs r)rrns -A&&& C S// M= 1 1 M+,>1NNNN F <'**L,@,C,CT6S[]a b bbr+ squash_nansc  |dvrtdt|\}g}tj|jt jrtd%|r dg|jz}|}dnttrt|j }|jtfdDtttkrtdD]}d||<tttz }tt} t!t#|D]\} } | | | | c| | <| | <tfdt!|j D} tfd t!|j D} t%j|| t)j| fz| }t-d |jnt-|j|j }|j dkrtd |j |j }|rt/t1j|t j|}t%j| }t9t1jt1j||j| }|j }t%j|tt t| z}t%j|tt }t%j|t%j |tC|d}t%j"|}t%j#|}t%j ||}t%j tC|d|}t%j$tC|dt%j%||dz }t%j$tC|dt%j%||dz }t%j&|tN}t%j&|tN}||z fdtt|D}|r||<n|(||t|}||<|t|}ngt/tSt1j|dt j|}t%j| }t%j&|tUj+|}t%j||dz }t%j"|}t%j#|}t%j ||}t%j tC|d|}t%j,tC|d||dz }t%j,tC|d||dz }t%j&|tN}t%j&|tN}t|}d|<t%j-tt |rt| znt| zdz |rdnff}t%j.||d||}t%j.||d||} dkr8t%j/||j d}t%j/||j d}|dkrlt%j0t%j|1|j|t%j|1|j|}n|dkr|}n|dkr|}n|dkr:t%j2|tC|d}t%j3|||}nP|dkr7t%jt%j0||tC|d}ntd|d|r:|r8 dkrt j |dg|}||}t%j&||jS)N)rlowerhighermidpointnearestzHmethod can only be 'linear', 'lower', 'higher', 'midpoint', or 'nearest'zLquantile does not support complex input, as the operation is poorly defined.rnrc38K|]}t|VdSrHr)r4axnds r)rqz_quantile..s.;;#B++;;;;;;r+z repeated axisc3*K|] \}}|v |VdSrHr3r4idxrrVs r)rqz_quantile..s+TTUSCtOOqOOOOTTr+c3*K|] \}}|v |VdSrHr3rs r)rqz_quantile..s+IIec!SD[[[[[[IIr+rz$q must be have rank <= 1, got shape rrcLg|] }tjt|z!Sr3)r broadcasted_iotar.)r4dim out_shapeq_ndims r)r6z_quantile..s< ; ; ; !#y#, ? ? ; ; ;r+Trr3) offset_dimscollapsed_slice_dimsstart_index_map).N)dimension_numbers slice_sizes)r)broadcast_dimensionsrrrr?rzmethod=z not recognized)4rurrrIr@r'r'r:ravelrvrrrprrr; enumeratesortedr rvrrr9rrisnanr-sortr logical_notr~rr&r@floorceilrrr{r.r<rr7_dtypeclampGatherDimensionNumbersgatherbroadcast_in_dimrrrZselect)!r,rrVrrXrkeepdimrkeep dimensionsr5sdo_not_touch_shape touch_shapeq_shapercountsshape_after_reductionlowhigh high_weight low_weightr low_value high_valuenrdnumsrpredrrrs! ` @@@r)rr~sE GGG _ ` ``a  "! ' qw 233e c d dd \af g  A DD$,17mmG B ;;;;d;;; ; ;D 3t99~~T""  ' ''gbkk uRyy>>CII %DeBiiJ&,,''BB1%/]JqM"jmZ]]TTTTi.@.@TTTTTIIIIy'9'9IIIIIK A)TY{-C-C,EEzRRA b!& ) )DD dAF + +D G' 6& aZZ EAGEE F FF G';Cv|A**A d###A #FLOO444qwYa b b bF"L uVS!677&@AA B B D DA _VU5==%9%9 : :F 376:a#3#34455A )A,,C 8A;;D'!S//KK33[AAJ '*S!$$cgc6A:&>&> ? ?C 7:dA&&fqj(A(A B BD "3 , ,C  #D# . .D//I ; ; ; ; ;c"78899 ; ; ;EeDkk ll4%,,IE$K5<<JJs6<??===rvqIIA d###A   0CA0F0FGGA 1q5A )A,,C 8A;;D'!S//KK33[AAJ )JsA&&QU 3 3C 9Za(($A 6 6D "3 , ,C  #D# . .Dw--KK  &!)HG vs7||f/Dq/HJJKK"*622wg    E  1c)n'2444IAtI%(3555J {{' IO=ACCCj(j6F=ACCCk x WSWY--ag66 CCWZ..qw77EEGGFF  FF  FF  6+z+s;; < rGrIrLrOrNrTrYr_raryr{cumsumcumprod nancumsum nancumprodrgetattrr|rrrrrrrr3r+r)rs#"""""........ :::::::::::::: !!!!!!HHHHHHHHHHHHHHHHHH-,,,,,MMMMMMMMMMMMMM |   S(3- %&BBBB         Sz3' (,BF-127 Dd %4*.>B(-AAAAAAAAAAAAFWWW " " " "GGGG"7777 ,,,, = = = = "S\`aaaKO38LP)-7777ba7DHNRAEG8G8G8G8G8T "S\`aaaLP49MQ*.VVVVbaVEI,1EI"&H9H9H9H9H9V "6tDDD=ADH*.MMMMEDM6:<@"&GFGFGFGFGFR "6tDDD=ADH*.MMMMEDM6:<@"&FFFFFFFFFFP "6tDDD=A!&IEIIIIIIEDI 6:/5=A/5/5/5/5/5/5b "6tDDD=A!&IEIIIIIIEDI 6:/5=A/5/5/5/5/5/5b7;<@"&+++++7;<@"&+++++    EI,1;#';;;;;;z "?MMMEI-2-1$(NM@ IM?DTTTT T K6;KKKKK K IM5:```` ` BJIM5:OOOOO "B4PPPJN6;3 3 3 3 QP3 lDH:?Q"&QQQQQQf "?@@@DHIN #'     A@ F9999*DH:?M"&MMMMMM^ "?@@@DHIN i#' i i i i iA@ i6:&=&=&=&=&=P "67776:87 "6777-1#('F'F'F'F87'FX8=       "67778BW W W W A@W t "?@@@X\+0%)b1b1b1b1A@b1J "?@@@X\+0%)G`G`G`G`A@G`TOOOOO(OOO " PQ8=+++++\ $ #BIszE J J J $ $RZu M M M & &r|SZ04 D D D ' ' s{15!EEE 33)SZ%$ GGB($ / /00+/"!     10 B BKe->%?@@@"deeeNRLT# dMZ]__ d d d d dfeA@ d BN0A(BCCC"deeeQUOW!& cP]P]P_P_ c c c c cfeDC cx3x3x3x3v BM/@'ABBB"deee48NV % 4P]} 4 4 4 4 4feCB 4 B 52C*DEEE"deee7;QY#( 7S`R_RaRa 7 7 7 7 7feFE 7 "IJJJ>B5:!/8/8/8/8KJ/8d "IJJJAE8=$5(5(5(5(KJ5(5(5(r+