uki] $dZddlmZdgZddlZddlmZddlZddlm Z ddl m Z m Z ddl ZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z$ddlm%Z%ddlm&Z&ddl'm(Z(ddl)m*Z*ddl+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6ddl7m8Z8m9Z9e9e:cZ:Z;e8e ddd dd!Z? d dd"Z@ d dd#ZAddd$ZBdddd%dd& dd'ZC d dd)ZDddd*ZEddd-ZF ddddd. dd/ZGdd0ZHdd1ZIdd2ZJ d dd3ZK d dd4ZLddd5ZMddd6 dd7ZNddd9dd:ZOdd;ZPdd<ZQdd=ZRdd>ZS d dd?ZT ddd dd@ZU d ddAZVddBZWdddC ddDZX d ddEZY d ddFZZddGZ[ddddH ddIZ\d8ddJ ddKZ]dddLZ^ ddMdN ddOZ_dddd%dd& ddPZ`dddQZa ddddR ddSZb d ddTZcddUZd d ddVZeddW ddXZf d ddYZgddZZhdd[Zi ddddR dd\Zjdd]Zkddd^Zld_Zmeneoepejeje1ejfZteuevewexfZydd`ZzdaZ{dd dbZ|d dcZ}ejefZeejfzZddZejdef d dgZejd dhZdiZdjZGdkdlZGdmdnZidoedpe{d(eJdqe}drdsdtdudvezdwe&jdxezdye&jdzezd{e&jd|ezd}e&jd~ezde&jdezde&jdddezde&jdezde&jd%dezde&j dezde&j d%idezde&j"dezde&j"d%dezde&j$dezde&j$d%dezde&j&dezde&j&d%dezde&j(dezde&j(d%dezde&j*dezde&j*d%dezde&j,dezde&j,d%dezde$j.dezde$j.d%dezde&j0dezde&j0d%dezde&j2ezde&j2d%ezde&j4ezde&j4d%dezde&j6ezde&j8ezde&j6d%ezde&j8d%e|d Zide j<de>de?de@deAdeBdeCdeDdeEdeFdeGdeHdeId(eJdeKdeLdeMideNdeOdeQd,eTdeUd+eVdeXdeYdeZdeOde\de]de^de_de`deadebecedeeefegehejele#j>edȜ ZeedɜZemeieSe[ePeWeRedʜZd˄Zd̄Zd̈́Zd΄Zd dτZddЄZdфZd҄ZdӄZdԄZy(zDefine methods which are dynamically added to JAX's Arrays and Tracers. This is done dynamically in order to avoid circular imports. ) annotationsregister_jax_array_methodsN)wraps)Any)CallableSequence)api)core)dtypes)literals)_ensure_index_tuple) ArrayImpl)lax)slicing) xla_client)array_api_metadata)array_creation)indexing) lax_numpy)tensor_contractions) reductions)ufuncs) PartitionSpec)Sharding)canonicalize_sharding NamedSharding)scatter)Array ArrayLikeDimSize DTypeLikeShape StaticScalar)safe_zipsafe_mapF)wherec6tj|||||S)zTest whether all array elements along a given axis evaluate to True. Refer to :func:`jax.numpy.all` for the full documentation. axisoutkeepdimsr&)rallselfr)r*r+r&s W/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/numpy/array_methods.py_allr0D 4S85 QQc6tj|||||S)zTest whether any array elements along a given axis evaluate to True. Refer to :func:`jax.numpy.any` for the full documentation. r()ranyr-s r/_anyr5Lr1r2c4tj||||S)zjReturn the index of the maximum value. Refer to :func:`jax.numpy.argmax` for the full documentation. r)r*r+)rargmaxr.r)r*r+s r/_argmaxr:T   $TsX FFr2c4tj||||S)zjReturn the index of the minimum value. Refer to :func:`jax.numpy.argmin` for the full documentation. r7)rargminr9s r/_argminr>\r;r2c2tj|||S)z{Return the indices that partially sort the array. Refer to :func:`jax.numpy.argpartition` for the full documentation. )kthr))r argpartition)r.r@r)s r/ _argpartitionrBds   #D 99r2T)kindorderstable descendingc8tj||||||S)zlReturn the indices that sort the array. Refer to :func:`jax.numpy.argsort` for the full documentation. r)rCrDrErF)rargsortr.r)rCrDrErFs r/_argsortrKks&   4dU"(Z AAr2copyc4tj||||S)a3Copy the array and cast to a specified dtype. This is implemented via :func:`jax.lax.convert_element_type`, which may have slightly different behavior than :meth:`numpy.ndarray.astype` in some cases. In particular, the details of float-to-int and int-to-float casts are implementation dependent. )rLdevice)rastype)r.dtyperLrNs r/_astyperQts   $D @@r2c4tj||||S)zConstruct an array choosing from elements of multiple arrays. Refer to :func:`jax.numpy.choose` for the full documentation. )choicesr*mode)rchoose)r.rSr*rTs r/_chooserVs   $St DDr2minmaxc2tj|||S)z|Return an array whose values are limited to a specified range. Refer to :func:`jax.numpy.clip` for full documentation. )rWrX)rclip)r.rWrXs r/_clipr[s #3 //r2)r*size fill_valuec8tj||||||S)zxReturn selected slices of this array along given axis. Refer to :func:`jax.numpy.compress` for full documentation. )r)r*r\r])rcompress)r. conditionr)r*r\r]s r/ _compressras$   It$C!%* >>r2c,tj|S)zlReturn the complex conjugate of the array. Refer to :func:`jax.numpy.conj` for the full documentation. )rconjr.s r/_conjres T r2c,tj|S)zqReturn the complex conjugate of the array. Refer to :func:`jax.numpy.conjugate` for the full documentation. )r conjugaterds r/ _conjugaterhs   $ r2c,tj|S)z]Return a copy of the array. Refer to :func:`jax.numpy.copy` for the full documentation. )rrLrds r/_copyrjs  r2c4tj||||S)zpReturn the cumulative product of the array. Refer to :func:`jax.numpy.cumprod` for the full documentation. r)rPr*)rcumprodr.r)rPr*s r/_cumprodros   Dt5c BBr2c4tj||||S)zkReturn the cumulative sum of the array. Refer to :func:`jax.numpy.cumsum` for the full documentation. rl)rcumsumrns r/_cumsumrrs   4d%S AAr2c4tj||||S)zsReturn the specified diagonal from the array. Refer to :func:`jax.numpy.diagonal` for the full documentation. )offsetaxis1axis2)rdiagonal)r.rtrurvs r/ _diagonalrxs   DuE JJr2 precisionpreferred_element_typec4tj||||S)zgCompute the dot product of two arrays. Refer to :func:`jax.numpy.dot` for the full documentation. ry)rdot)r.brzr{s r/_dotrs  qIVl mmr2C out_shardingc2tj|||S)zlFlatten array into a 1-dimensional shape. Refer to :func:`jax.numpy.ravel` for the full documentation. rDr)rravel)r.rDrs r/_flattenrs U FFr2c,tj|S)z'Return the imaginary part of the array.)rimagrds r/_imag_propertyr T r2ctjtj|d}t j |j tjrtd|j |j|S)zFCopy an element of an array to a standard Python scalar and return it.z/This occurred in the item() method of jax.Array)contextz$No Python scalar type for arr.dtype=) r concrete_or_errornpasarrayr issubdtyperPextended TypeErroritem)r.argsarrs r/_itemrsZ rzz49jk# tzz6??3 ; = >> 4r2c.|jjS)z%Length of one array element in bytes.)rPitemsizerds r/_itemsize_propertyrs   r2c,tj|S)zfCompute the (batched) matrix transpose. Refer to :func:`jax.numpy.matrix_transpose` for details. )rmatrix_transposerds r/_matrix_transpose_propertyrs  # #D ))r2c8tj||||||S)zyReturn the maximum of array elements along a given axis. Refer to :func:`jax.numpy.max` for the full documentation. r)r*r+initialr&)rrXr.r)r*r+rr&s r/_maxr" 4S8 'u 66r2c8tj||||||S)zwReturn the mean of array elements along a given axis. Refer to :func:`jax.numpy.mean` for the full documentation. )r)rPr*r+r&)rmean)r.r)rPr*r+r&s r/_meanrs" D3"*% 99r2c8tj||||||S)zyReturn the minimum of array elements along a given axis. Refer to :func:`jax.numpy.min` for the full documentation. r)rrWrs r/_minrrr2cZtj||jjzS)z2Total bytes consumed by the elements of the array.)rr\rPrrds r/_nbytes_propertyrs ,, ,,r2)r]r\c2tj|||S)ztReturn indices of nonzero elements of an array. Refer to :func:`jax.numpy.nonzero` for the full documentation. )r\r])rnonzero)r.r]r\s r/_nonzeror s   4dz BBr2c <tj||||||||S)zyReturn product of the array elements over a given axis. Refer to :func:`jax.numpy.prod` for the full documentation. )r)rPr*r+rr&promote_integers)rprodr.r)rPr*r+rr&rs r/_prodrs) D3!(HX ZZr2c4tj||||S)zrReturn the peak-to-peak range along a given axis. Refer to :func:`jax.numpy.ptp` for the full documentation. r7)rptpr9s r/_ptprs 4S8 DDr2c,tj|S)z"Return the real part of the array.)rrealrds r/_real_propertyr&rr2)total_repeat_lengthrc6tj|||||S)znConstruct an array from repeated elements. Refer to :func:`jax.numpy.repeat` for the full documentation. )repeatsr)rr)rrepeat)r.rr)rrs r/_repeatr*s#   $d.A'3 55r2rcd}t|t|dk(r|dn|}|dk(rtj||d|S|dk(rt t |j ddd}t|d }|dn;|j|jj|jddd  }tj||ddd||jS|d k(r td td|d)z|Returns an array containing the same data with a new shape. Refer to :func:`jax.numpy.reshape` for full documentation. TrrNrFz jnp.reshape) partitions)specAz&np.reshape order=A is not implemented.z'Unexpected value for 'order' argument: .) _compute_newshapelenrreshapelistrangendimrupdaterTNotImplementedError ValueError)r.rDrr__tracebackhide__newshapedimss r/_reshaper5s  tD QT!WD I( c\ ;;tXt, GG | dii 2& 'D(}EL$,*=*=""))\5F5Ftt5L)M+>+O ;;tXdd^T M O OO | F GG >ugQG HHr2c2tj|||S)zgRound array elements to a given decimal. Refer to :func:`jax.numpy.round` for full documentation. )decimalsr*)rround)r.rr*s r/_roundrKs c ::r2scan)methodc6tj|||||S)zqPerform a binary search within a sorted array. Refer to :func:`jax.numpy.searchsorted` for full documentation.)sidesorterr)r searchsorted)r.vrrrs r/ _searchsortedrRs   ad6& QQr2c8tj||||||S)z_Return a sorted copy of an array. Refer to :func:`jax.numpy.sort` for full documentation. rH)rsortrJs r/_sortrYs" 4d%%* >>r2c0tj||S)zmRemove one or more length-1 axes from array. Refer to :func:`jax.numpy.squeeze` for full documentation. )r))rsqueeze)r.r)s r/_squeezerbs   4d ++r2)r& correctionc <tj||||||||S)zoCompute the standard deviation along a given axis. Refer to :func:`jax.numpy.std` for full documentation. r)rPr*ddofr+r&r)rstdr.r)rPr*rr+r&rs r/_stdris' 4u#DS[#  <tAw+GD t $D   T4 ((r2c,tj|S)z]Compute the all-axis array transpose. Refer to :func:`jax.numpy.transpose` for details. )rrrds r/_transpose_propertyrs   T ""r2c <tj||||||||S)zeCompute the variance along a given axis. Refer to :func:`jax.numpy.var` for full documentation. r)rvarrs r/_varrs( 4u#D!): OOr2c } ttjtDcgc]\}}t |t us|dk(s|!}}}t |dkDrtd||r|\}gd||dzd}tdgj|Drpjtj|zdk7rKtdjdjd |d tj|d j tjj|}|gd|||dzdStd gjDrajtjk7r?tdjdjd |dtjd tfdDS#gYxYwcc}}w)z)Fixes a -1 value in newshape, if present.rrz>can only specify one unknown axis size with a `-1` value, got Nc3<K|]}t|tywN isinstanceint.0ds r/ z$_compute_newshape..s C1Jq#  Crzcannot reshape array of shape z (size z ) into shape z. because the product of specified axis sizes (z) does not evenly divide c3<K|]}t|tywr r r s r/rz$_compute_newshape..s @1Jq#  @r)c3K|]=}tj|dr!tjj n|?yw)rN)r definitely_equaldivide_shape_sizesshape)rrrrs r/rz$_compute_newshape..sFI:;$''2.'' 8<<456IsAA)iterr canonicalize_shape enumeratetyper rrr,rr\mathrcancel_divide_tracerstuple)rr orig_newshapeirneg1s other_sizesszs`` r/rrs-N $ $X .("8, KAQ3171 K% KZ!^ (/+ ,, BA2HRaL28AaCD>2K C(B#))(Bk(B CC 499[))Q. 6syyk S$$1?3//3yy/E.FG++.88*6 77  # #CII{ ;B ~ 1x| 1R 1(1Q34. 11 @(?#))(?h(? @@ DIIh'' 6syyk S$$1?'$))H:M9NaQ RR I?GI II1zH Ks G)G4G4G4)G1c| td||Stj|d}tj|j}tj|}|j dk(r>||k7r t dttj|d|jS|jd|z|zdk7r t d|j|k(r|S|jtk(rt|jd |Stj|jt j"rg|jdd|jdd z}tj$|jj}t'j(|j*}t-j.||| j0d ddd fj3|j4j0d d dd fj3|j6}t||S|tk(r-t|t j8jtStj|t j"rPt|tj$|jj|}|d ddd fd|d d dd fzzS||krN||z} |j:g|jdd|jd| z| }tj<||S||kDrTtj<||}|j:g|jdd|jd|jdzStj<||S)aReturn a bitwise copy of the array, viewed as a new dtype. This is fuller-featured wrapper around :func:`jax.lax.bitcast_convert_type`. If the source and target dtype have the same bitwidth, the result has the same shape as the input array. If the bitwidth of the target dtype is different from the source, the size of the last axis of the result is adjusted accordingly. >>> jnp.zeros([1,2,3], dtype=jnp.int16).view(jnp.int8).shape (1, 2, 6) >>> jnp.zeros([1,2,4], dtype=jnp.int8).view(jnp.int16).shape (1, 2, 2) Conversions involving booleans are not well-defined in all situations. With regards to the shape of result as explained above, booleans are treated as having a bitwidth of 8. However, when converting to a boolean array, the input should only contain 0 or 1 bytes. Otherwise, results may be unpredictable or may change depending on how the result is used. This conversion is guaranteed and safe:: >>> jnp.array([1, 0, 1], dtype=jnp.int8).view(jnp.bool_) Array([ True, False, True], dtype=bool) However, there are no guarantees about the results of any expression involving a view such as this: ``jnp.array([1, 2, 3], dtype=jnp.int8).view(jnp.bool_)``. In particular, the results may change between JAX releases and depending on the platform. To safely convert such an array to a boolean array, compare it with `0`:: >>> jnp.array([1, 2, 0], dtype=jnp.int8) != 0 Array([ True, True, False], dtype=bool) Args: dtype: An optional output dtype. If not specified, the output dtype is the same as the input dtype. type: Not implemented; accepted for NumPy compatibility. Returns: The array, viewed as the new dtype. Unlike NumPy, the array may or may not be a copy of the input array. Nz1`type` argument of array.view() is not supported.viewrzDview() of a 0d array is only supported if the itemsize is unchanged.rrzuWhen changing to a larger dtype, its size must be a divisor of the total size in bytes of the last axis of the array.uint8r.ry?)rr !check_and_canonicalize_user_dtype itemsize_bitsrPrr_viewr expand_dimsrrboolrOrrrcomplexfloatingfinfor typeofshardingrzerosatsetrrr'rbitcast_convert_type) r.rPrnbits_in nbits_out new_shape new_dtype new_shardingr*factors r/r,r,s V  Q RR ] K  2 25& A%  ! !$** -(""5)) YY!^9 ] ^^ t,e 4 < < >> jjnx9,1 Q RR ZZ5 K ZZ4 W%u --$**b&8&896$**Sb/64::b>A#56I +11I;;t$--L  IL Q RQTT  3tyy> RQTT  3tyy>  u  d] rxx ' ' --%!3!34 iooe,22 3 : :5 AC sADqDy>BS!$Q$Y/ //  ( "F $,, J 3B JB6)A J6 JC  # #C //) " "4 /C 3;; F #2 F "  " (E FF  # #D% 00r2ctd)z8Not implemented: Use :meth:`~jax.Array.flatten` instead.zRJAX Arrays do not implement the arr.flat property: consider arr.flatten() instead.rrds r/_notimplemented_flatr?Js> ??r2cfd}|S)Nc (t|dr|j}r||fn||f}t|tr|St |t vr@t ddt |djdt |djtS)N __jax_array__z unsupported operand type(s) for z: rz and r) hasattrrBr _accepted_binop_typesr_rejected_binop_typesr__name__NotImplemented)r.otherr binary_opopcharswaps r/deferring_binary_opz7_defer_to_unrecognized_arg..deferring_binary_op\suo&!!#e E4=tUmD%./   E{++ 8d1g//2%T!W 8N8N7QS TT r2)rJrIrKrLs``` r/_defer_to_unrecognized_argrNZs  r2cLd}t|jt|)NzJAX arrays are immutable and do not support in-place item assignment. Instead of x[idx] = y, use x = x.at[idx].set(y) or another .at[] method: https://docs.jax.dev/en/latest/_autosummary/jax.numpy.ndarray.at.html)rformatr)r.r xmsgs r/_unimplemented_setitemrSjs$ R# #**T$Z())r2cjtj||xsd}||jtS|S)Nr)r)rrrOr )numberndigitsr*s r/_operator_roundrWps-A6##OC44r2c$~|jSr )rL)r.memos r/ _deepcopyrZus r2cRtd|Drddl}|jStS)Nc3<K|]}t|tywr ) issubclass_HANDLED_ARRAY_TYPES)rts r/rz#__array_module__..s<A+ , $(+ !TAGGAJ5F(G H1#++a  HH HsA c#K||jdkDr|ytj|jd|\}}t|D]}t j |||z| |rt j |||z|yyw)Nr)rrdivmodrridynamic_slice_in_dim)rQr\ num_chunkstailr s r/ _chunk_iterr}s AGGAJ G}}QWWQZ6J : @  , ,QD$ ??@  , ,Q T0A4 HH sB B c.tj||Sr )rrewriting_take)r.rs r/_getitemrs  t ,,r2c8eZdZUdZdZded<d dZd dZd dZy) _IndexUpdateHelperaHelper property for index update functionality. The ``at`` property provides a functionally pure equivalent of in-place array modifications. In particular: ============================== ================================ Alternate syntax Equivalent In-place expression ============================== ================================ ``x = x.at[idx].set(y)`` ``x[idx] = y`` ``x = x.at[idx].add(y)`` ``x[idx] += y`` ``x = x.at[idx].subtract(y)`` ``x[idx] -= y`` ``x = x.at[idx].multiply(y)`` ``x[idx] *= y`` ``x = x.at[idx].divide(y)`` ``x[idx] /= y`` ``x = x.at[idx].power(y)`` ``x[idx] **= y`` ``x = x.at[idx].min(y)`` ``x[idx] = minimum(x[idx], y)`` ``x = x.at[idx].max(y)`` ``x[idx] = maximum(x[idx], y)`` ``x = x.at[idx].apply(ufunc)`` ``ufunc.at(x, idx)`` ``x = x.at[idx].get()`` ``x = x[idx]`` ============================== ================================ None of the ``x.at`` expressions modify the original ``x``; instead they return a modified copy of ``x``. However, inside a :py:func:`~jax.jit` compiled function, expressions like :code:`x = x.at[idx].set(y)` are guaranteed to be applied in-place. Unlike NumPy in-place operations such as :code:`x[idx] += y`, if multiple indices refer to the same location, all updates will be applied (NumPy would only apply the last update, rather than applying all updates.) The order in which conflicting updates are applied is implementation-defined and may be nondeterministic (e.g., due to concurrency on some hardware platforms). By default, JAX assumes that all indices are in-bounds. Alternative out-of-bound index semantics can be specified via the ``mode`` parameter (see below). Args: mode: string specifying out-of-bound indexing mode. Options are: - ``"promise_in_bounds"``: (default) The user promises that indices are in bounds. No additional checking will be performed. In practice, this means that out-of-bounds indices in ``get()`` will be clipped, and out-of-bounds indices in ``set()``, ``add()``, etc. will be dropped. - ``"clip"``: clamp out of bounds indices into valid range. - ``"drop"``: ignore out-of-bound indices. - ``"fill"``: alias for ``"drop"``. For `get()`, the optional ``fill_value`` argument specifies the value that will be returned. See :class:`jax.lax.GatherScatterMode` for more details. wrap_negative_indices: If True (default) then negative indices indicate position from the end of the array, similar to Python and NumPy indexing. If False, then negative indices are considered out-of-bounds and behave according to the ``mode`` parameter. fill_value: Only applies to the ``get()`` method: the fill value to return for out-of-bounds slices when ``mode`` is ``'fill'``. Ignored otherwise. Defaults to ``NaN`` for inexact types, the largest negative value for signed types, the largest positive value for unsigned types, and ``True`` for booleans. indices_are_sorted: If True, the implementation will assume that the (normalized) indices passed to ``at[]`` are sorted in ascending order, which can lead to more efficient execution on some backends. If True but the indices are not actually sorted, the output is undefined. unique_indices: If True, the implementation will assume that the (normalized) indices passed to ``at[]`` are unique, which can result in more efficient execution on some backends. If True but the indices are not actually unique, the output is undefined. Examples: >>> x = jnp.arange(5.0) >>> x Array([0., 1., 2., 3., 4.], dtype=float32) >>> x.at[2].get() Array(2., dtype=float32) >>> x.at[2].add(10) Array([ 0., 1., 12., 3., 4.], dtype=float32) By default, out-of-bound indices are ignored in updates, but this behavior can be controlled with the ``mode`` parameter: >>> x.at[10].add(10) # dropped Array([0., 1., 2., 3., 4.], dtype=float32) >>> x.at[20].add(10, mode='clip') # clipped Array([ 0., 1., 2., 3., 14.], dtype=float32) For ``get()``, out-of-bound indices are clipped by default: >>> x.at[20].get() # out-of-bounds indices clipped Array(4., dtype=float32) >>> x.at[20].get(mode='fill') # out-of-bounds indices filled with NaN Array(nan, dtype=float32) >>> x.at[20].get(mode='fill', fill_value=-1) # custom fill value Array(-1., dtype=float32) Negative indices count from the end of the array, but this behavior can be disabled by setting ``wrap_negative_indices = False``: >>> x.at[-1].set(99) Array([ 0., 1., 2., 3., 99.], dtype=float32) >>> x.at[-1].set(99, wrap_negative_indices=False, mode='drop') # dropped! Array([0., 1., 2., 3., 4.], dtype=float32) arrayrrc||_yr r)r.rs r/__init__z_IndexUpdateHelper.__init__s DJr2c.t|j|Sr )_IndexUpdateRefr)r.indexs r/ __getitem__z_IndexUpdateHelper.__getitem__s 4::u --r2c"d|jdS)Nz_IndexUpdateHelper(rrrds r/__repr__z_IndexUpdateHelper.__repr__s a 00r2N)rr)r scatter.Indexreturnrrstr) rF __module__ __qualname____doc__ __slots____annotations__rrrrMr2r/rrs$aD) ,.1r2rceZdZUdZdZded<ded<ddZddZd d d d d d d  dd Zd d d d d d ddZ d d d d d ddZ d d d d d d ddZ d d d d d ddZ d d d d d ddZ e Zd d d d d ddZd d d d d ddZd d d d d ddZd d d d d ddZy ) raHelper object to call indexed update functions for an (advanced) index. This object references a source array and a specific indexer into that array. Methods on this object return copies of the source array that have been modified at the positions specified by the indexer. rrrrrrc ||_||_yr r)r.rrs r/rz_IndexUpdateRef.__init__-sDJDJr2c<d|jd|jdS)Nz_IndexUpdateRef(z, rrrds r/rz_IndexUpdateRef.__repr__1s djj^2djj^1 ==r2FNT)rrrTr]rwrap_negative_indicesc |$t|ttfsJt|d}t j |j |j||||||S)azEquivalent to ``x[idx]``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexing ` ``x[idx]``. This function differs from the usual array indexing syntax in that it allows additional keyword arguments ``indices_are_sorted`` and ``unique_indices`` to be passed. See :func:`jax.numpy.ndarray.at` for details. z.get)rrrTr]normalize_indicesr)r rrrrrrr)r.rrrTr]rrs r/getz_IndexUpdateRef.get4s[  }m&D EE E*<@l  " "4::tzz6H2@t.85J0<  >>r2)rrrTrrc |$t|ttfsJt|d}t j |j |j|tj||||| S)zPure equivalent of ``x[idx] = y``. Returns the value of ``x`` that would result from the NumPy-style :mod:`indexed assignment ` ``x[idx] = y``. See :func:`jax.numpy.ndarray.at` for details. z.setrrrTrr) r rrrr_scatter_updaterrrir.valuesrrrTrrs r/r5z_IndexUpdateRef.setLsb  }m&D EE E*<@l  " " DJJ (;(;-n  /  11r2)rrrTrc fd}tj|j|jt j |j|||||S)a@Pure equivalent of ``func.at(x, idx)`` for a unary ufunc ``func``. Returns the value of ``x`` that would result from applying the unary function ``func`` to ``x`` at the given indices. This is similar to ``x.at[idx].set(func(x[idx]))``, but differs in the case of repeated indices: in ``x.at[idx].apply(func)``, repeated indices result in the function being applied multiple times. Note that in the current implementation, ``scatter_apply`` is not compatible with automatic differentiation. See :func:`jax.numpy.ndarray.at` for details. cNtj|||fd|ji|S)N update_shape)ri scatter_applyr)rQryrkwargsfuncs r/_scatter_applyz-_IndexUpdateRef.apply.._scatter_applyrs)  & &q'4 ^AGG ^W] ^^r2rrrTr)rrrrr_zero)r.rrrrTrrs ` r/applyz_IndexUpdateRef.applyasE"_  " " DJJ $** 5~-n %: <` ``x[idx] += y``. See :func:`jax.numpy.ndarray.at` for details. z.addr) r rrrrrrrri scatter_addrs r/addz_IndexUpdateRef.addysb  }m&D EE E*<@l  " " DJJ (?(?-n  /  11r2c tj|j|j|tj ||||S)zPure equivalent of ``x[idx] -= y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] -= y``. See :func:`jax.numpy.ndarray.at` for details. r)rrrrri scatter_subr.rrrrTrs r/subtractz_IndexUpdateRef.subtracts;  " "4::tzz6#.#:#:6H2@t5J  LLr2c tj|j|j|tj ||||S)zPure equivalent of ``x[idx] *= y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] *= y``. See :func:`jax.numpy.ndarray.at` for details. r)rrrrri scatter_mulrs r/multiplyz_IndexUpdateRef.multiplys<  " "4::tzz6#.#:#:6H2@(,@U  WWr2c tj|jtjt j |j|j|tj||||S)zPure equivalent of ``x[idx] /= y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] /= y``. See :func:`jax.numpy.ndarray.at` for details. r) rdividerrrr ones_likerrirrs r/rz_IndexUpdateRef.divides[ == jj n66tzzBDJJPV)551C-;$0E G HHr2c tj|jtjt j |j|j|tj||||S)zPure equivalent of ``x[idx] **= y``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] **= y``. See :func:`jax.numpy.ndarray.at` for details. r) rpowerrrrrrrrirrs r/rz_IndexUpdateRef.powers[ << jj n66tzzBDJJPV)551C-;$0E G HHr2c tj|j|j|tj ||||S)a Pure equivalent of ``x[idx] = minimum(x[idx], y)``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] = minimum(x[idx], y)``. See :func:`jax.numpy.ndarray.at` for details. r)rrrrri scatter_minrs r/rWz_IndexUpdateRef.min;  " "4::tzz6#.#:#:6H2@t5J  LLr2c tj|j|j|tj ||||S)a Pure equivalent of ``x[idx] = maximum(x[idx], y)``. Returns the value of ``x`` that would result from the NumPy-style :mod:indexed assignment ` ``x[idx] = maximum(x[idx], y)``. See :func:`jax.numpy.ndarray.at` for details. r)rrrrri scatter_maxrs r/rXz_IndexUpdateRef.maxrr2)rrrrr) rr.rr.rT*str | lax_slicing.GatherScatterMode | Noner]ArrayLike | Noner$NamedSharding | PartitionSpec | Nonerr.)rrrr.rr.rTrrrrr.rNone) rzCallable[[ArrayLike], Array]rr.rr.rTrrr.rr)rrrr.rr.rTrrrrr.rr) rrrr.rr.rTrrr.rr)rFrrrrrrrrr5rrrrmulrrrWrXrMr2r/rr!s !) , >/4E=A)-?C(, >:>&>=>"& >0BG!&=A?C(, 11:1=1"& 126 1,(-U?C*.< $<>B<<<$(<49<2&+5=A?C(, 1"1<@1:1=1"& 127 1,+0BF-1L#'LAEL?L'+L7<L$+0BF-1W#'WAEW?W'+W7<W #).e@D+/H!%H?CH=H%)H5:H((-U?C*.H $H>BH<H$(H49H(&+5=A(,L"L<@L:L"&L27L&&+5=A(,L"L<@L:L"&L27Lr2rgetitemsetitemdeepcopynegc,tj|Sr )rnegativerds r/rfood+r2posc,tj|Sr )rpositiverds r/rrrr2eqz==nez!=lt<lez<=gt>gez>=absc,tj|Sr )rrrds r/rrsfjj&r2r+radd)rKsub-rsubr*rmultruediv/rtruedivfloordivz// rfloordivryrdivmodmod%rmodpowz**rpowmatmul@rmatmuland&randor|^c,tj|Sr )r bitwise_notrds r/rr!s++D1r2z<>) rorxorrxorinvertlshiftrshiftrlshiftrrshiftr__array_namespace__r,r4r8r=rArIrOrUrZr_rcrgrmrqrwr}flattenrrrrrrrrrrrrr) rrr to_devicerrrr%_splitrt)r}rw)flatrmTrrnbytesrr4ctjD]\}}t|d|t| tjD]%\}}t||t j |'tjD]%\}}t||t j|'t|dtty)N_ _array_module) _array_operatorsitemssetattr staticmethod_array_methodsr aval_method_array_properties aval_propertyrd) shaped_array operator_namefunction method_namer prop_nameprops r/_set_shaped_array_attributesrjs "2!7!7!9GmX LAm_-|H/EFG,113Ak6 L+t'7'7'?@A*002?oi L)T%7%7%=>? ,6F)GHr2cfd}|S)NcDt|jd|g|S)Nr )getattraval)r.rnames r/opz%_forward_operator_to_aval..opys& )7499$j )$ 6 66r2rM)rrs` r/_forward_operator_to_avalr xs 7 )r2cfd}|S)Nc\d}t|jj|g|i|S)NT)rrfun)r.rrrrs r/methz%_forward_method_to_aval..meth~s1 '7499d # ' ' >t >v >>r2rM)rr$s` r/_forward_method_to_avalr%}s? +r2c$tfd}|S)NcNt|jj|Sr )rrfget)r.rs r/rz'_forward_property_to_aval..props 499d # ( ( ..r2)property)rrs` r/_forward_property_to_avalr*s / / +r2ctD]!}||vst|d|dt|#tD]}||vst||t |t D]}||vst||t |yN__)r r r rr%rr*)tracerexcluderrrs r/_set_tracer_aval_forwardingr0s'XmG# f=/,.G .VWX$Ik'! fk#:;#GHI%Gi fi!:9!EFGr2cbfd}tjD]\}}|d|d|tjD]\}}|||tjD]\}} ||t | t jD]\} } t | | y)Nc<|vryr|vrt||yyr )r ) attr_nametarget array_implr/includes r/ maybe_setattrz1_set_array_base_attributes..maybe_setattrs.yG3 i7* j)V,+r2r-)r r rrr)_impl_only_array_methodsr ) r5r6r/r7rrrrrrrrs ``` r/_set_array_base_attributesr9s- "2!7!7!94mXB}oR((34+113'k6+v&'*002-oi)Xd^,--224$jdD Jd#$r2c&t|dty)Nrd)r rd)r5s r/_set_array_attributesr;s *(*:;r2cTtjt|fd}|S)Nc td)NzCannot call abstract method r>)rrrs r/rz%_make_abstract_method..methods  oi Iy *9d; <>>r2cttjttdht tj htdtttty)z9Call this function once to register methods of JAX arraysr)r/r4N) rr ShapedArrayr9rr0Tracerr8r;rCrrMr2r/rrsFt//0Y@dkk3T5M3Tt3TU "e$r2)NNF) r.rr)reductions.Axisr*rr+r.r&rrr)NNN) r.rr) int | Noner*rr+z bool | Nonerr)r)r.rr@r r)r rr)r.rr)rHrCrrDrrEr.rFr.rr)FN) r.rrPDTypeLike | NonerLr.rNzxc.Device | Sharding | Nonerr)Nraise) r.rrSzSequence[ArrayLike]r*rrTrrr)NN)r.rrWrrXrrrr )r.rr`rr)rHr*rr\rHr]rrr)r.rrr) r.rr)rGrPrIr*rrr)rrr) r.rrtr rur rvr rr) r.rr~rrzzlax.PrecisionLiker{rIrr)r)r.rrDrrr)r.rrr rzbool | int | float | complex)r.rrr )r.r)NNFNN)r.rr)rGr*rr+r.rrr&rrr)NNNF)r.rr)rGrPrIr*rr+r.r&rrr)r.rr]z(None | ArrayLike | tuple[ArrayLike, ...]r\rHrztuple[Array, ...])NNNFNNT)r.rr)rGrPrIr*rr+r.rrr&rrr.rr) r.rr)rGr*rr+r.rr) r.rrrr)rHrrHrrrr)r.rrrrDrrr)rN)r.rrr r*rrr)leftN) r.rrrrrrrrrrr)r.rr)rGrr)NNNrF)r.rr)rGrPrIr*rrr r+r.r&rrzint | float | Nonerr)r.rrur rvr rr)NNNFFN)r.rrrr)rHr*rrTz str | Nonerr.rr.r]zStaticScalar | Nonerr)r.rrNzxc.Device | Shardingrzint | Any | None)rrrNN)r.rrtzint | ArrayLikerur rvr rPrIr*rrr)r.rrrrr)rrrzDimSize | Shaperr")r.rrPrIrrrr)F)rUrrVrHrr)r.rrYrrr) r.rrltuple[tuple[int, ...]]rmrLrnrLr list[Array])rQrrrM)rM)r __future__r__all__r> functoolsrrtypingrcollections.abcrrrarjax._srcr r r r jax._src.api_utilr jax._src.arrayr jax._src.laxrrri jax._src.librxcjax._src.numpyrrrrrrr jax._src.pjitrjax._src.shardingrjax._src.sharding_implsrr jax._src.opsrjax._src.typingrrr r!r"r# jax._src.utilr$r%map unsafe_maprh unsafe_zipr0r5r:r>rBrKrQrVr[rarerhrjrorrrxrrrrrrrrrrrrrrrrrrrrrrrrrrrrrrr,r?r floatcomplexgenericndarray TypedNdArrayrDrrr5dictrErNrSrWrZrF_JAX_ARRAY_TYPESr^rdjitrtrwr}rrrequal not_equalless less_equalgreater greater_equalrrr true_divide floor_divideryrrr bitwise_and bitwise_or bitwise_xor left_shift right_shiftr rrvrr8rrr r%r*r0r9r;r@rCrrMr2r/rxs " # ' (  .1$/)-)#$.%!'&H UU,CZCZAER>BRR+;RGLRAER>BRR+;RGLR?C$(G!G-2G?C$(G!G-2G:AUY UAA.2A?DA@E26 A/ A;@ AE0"&>6:!%q>>/3>>3<>EJ> SWCC"'CRVBB!&BKGK48n!1n=BnGDG*AE=A#'66*:6 6,16PT-29$(99&*9!9-29AE=A#'66*:6 6,16-UY $CC):CPT-2FJ#' Z Z&* Z# Z3C Z! Z-2 ZAEEE$)E 5.2AE 5!+ 5> 5JO 547TII,;:@-1RDJR*R>AROTR>dTe>>&*>?C>PU>,OS;@<#'$<, &, #C 4, $S&**4 @,  #C 9!," $S&// E#,$ #C 9%,& $S&// E',( 'V-?-? @),* (f.@.@tL+,, (v/B/BC-,.)$0C0C$O/,0 &x ?1,2 '&--d K3,4 #C 45,6 $S&**4 @7,8 #D&,, 79,: $T6< '-@-G-Gd S?,@ #C);); -> ? &tV-?-? @ 'f.?.?d K 'f.@.@t L W,\/+??/// G /  G / - / X/ G/ G/ %/ i/ %/z/ %/ X/  G!/" i#/$%/& X'/( %)/*+/, %-/.//0 X1/2 %3/45/6 87/8 G9/: X;/< 6=/>-?/@ %A/B XC/DE/F     OO]/d "      I   G$&< >%r2