ukidZddlmZddlZddlZddlmZddlZddlZddl m Z m Z ddl m Z ddlZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZddlmZddlmZddlmZddlm Z ddlm!Z"ddlm#Z#ddlm$Z$ddlm%Z%ddl&m'Z'ddl(m)Z)ddl*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2m3Z3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:m;Z;e9dZ<Gdd ejzZ>Gd!d"e Z? dLd#Z@e0ejd$d$%Gd&d'ZBe< dM dNd)ZCejd*+ dMdOd,ZEd-ZFe<ejd.+ dP dQd/ZGd0ZHe<ejd1+ dRdd2 dSd3ZIdTd4ZJdTd5ZKd6ZLd7ZMdd8 dUd9ZNGd:d;ejzZOd(d(ddd$deOjd< dVd=ZQd>ZRGd?d@e ZSd$dA dWdBZTdCZUdDZVdEZWdFZXdGZYdHZZetfKPTv2 13167 7 7rOct|jD]\}}|jtjk(s$t |j tsJtd|j j|j j|j jfDrtd|j d|y)zwCheck that all slices have static start/stop/step values. Raises an IndexError in case of non-static entries. c32K|]}t|ywN)._is_slice_element_none_or_constant_or_symbolic).0vals rM z,NDIndexer.validate_slices..s QB#FQz+Slice entries must be static integers. Got at position N) rarhrZr*r5r4rYr,allstartstopsteprI)rrrKs rMvalidate_sliceszNDIndexer.validate_slicess #4<<0F # IOO ##))U+++Q"yy  OQQ""%))M(EF F FrOc g}t|jD] \}}|jtjk7r|j |6t j|js2tjt j|jt|jttjt t"j$t&fsJtj(|jdk(rM|j*dk(sJ|j t-t|j|jd;tj.|j}|j*Dcgc]}|j.|}}t1dt3||Dst5d|d|d|tj6tj8|j}|j;dt=||j*Dt?|j.| Scc}w) zReturns a new NDIndexer with boolean indices replaced by array indices. The only exception are scalar boolean indices, which are left in-place. rrVr`c3.K|] \}}|d|fvywrNrV)rs1s2s rMrz0NDIndexer.expand_bool_indices..sL62r2wLsz.s2`")!T*yW[V]^^`s*,ry) rarhrZr*r9rbr is_concreterYrNonConcreteBooleanIndexErrorget_avalr4rDr:r;r rr<listrcr\rXrirziprIwhererCextendr%rv)rexpanded_indicesrrK idx_shapermexpected_shapeexpanded_indices_raws rMexpand_bool_indiceszNDIndexer.expand_bool_indicess +-"4<<0` # I%% %$   cii (11$-- 2JKK  D"**eX=R=RTX#Y ZZ Z  q   B&&& $syy/sww^` ab((399%i/2/@/@A! 1 AnA LSN-KL L$:VI;k.AQST TXXbjj&;<`-56JCL]L]-^``'`* 4::/? @@BsINc .t|j}t|d|jDn|}t|j}d}t|jD] \}}|jt j k(rtj|jdk(rp|j|d|j|dttjt|jt j|f||<|dz }t|j }t|j|jt#t%|||z||<||z } |dn t#|}t'|t#||fS)Nc3 K|]}dywrrV)r_s rMrz7NDIndexer.expand_scalar_bool_indices..s7qd7s rr_rZr\r`rhri)rrirhrarZr*r9r:rcrYinsertrXaranger~r?rdr\rfrgrv) r sharding_spec new_shapenew_sharding_spec new_indicesrprmrKrqs rMexpand_scalar_bool_indicesz$NDIndexer.expand_scalar_bool_indicessRTZZ I=;P7DJJ7Vcdt||$KKDLL)"3 I%% %"''#))*<*AA  D)$ ))C N #X Aq **+ $ ggk;3K LM A z! "!. 55AR;S [i0@ ACT TTrOc|jDcgc]]}t|jtr?t t j |j|j|jn|_}}t||jScc}w)Nrr) rhr4rYrrXrrCrZr\rvri)rrKrs rMconvert_sequences_to_arraysz%NDIndexer.convert_sequences_to_arrayssuJN,,XCFjH5y00;X[XiXij;>?XKX [ ;;XsA"B c &g}d}|jD]}|t|jz }|jtj k(rG|jD]7}|j ttdtj|f9|j |t|t|jD]7}|j ttdtj|f9t|j|S)zq Returns a new indexer with ellipsis and implicit trailing slices replaced by explicit empty slices. rNr`ry) rhrdr\rZr*r3rbrXr,r5rgrirv)rexpandedconsumedrKrs rMexpand_ellipseszNDIndexer.expand_ellipsess #%HH||#c''((h I&& &%% fD //+E$KY__]a\cd e f  hDJJ0bookd Y]X_`ab 4::x 88rOcdg}|jD]}|jtjk(r|j\}|j |}t |jtjr |j}n*|jdkr|j|zn |j}|jt||j|j|jtjk(rt |jttjtj fsJ|j\}t#j$|jj&tjr |j}n|j |}t)j*|r!t-j.|j|}n=t-j0t)j2||jj&}t-j4|jdkt-j6|j||j}|jt||j|jx|j|t9||j S)Nrrr)rhrZr*r7r\rir4rYr:unsignedintegerrbrXr?r r;rr<r r=r>r is_constant_dimr_constconvert_element_typedimension_as_valueselectaddrv)rrrKrr normed_indexs rMrzNDIndexer.normalize_indices1s%'K||  I%% %!!**T* cii!3!3 4 # ,-0YY]T) ,;|PSPaPabc 77ioo %#))eRZZ9N9N%OPPP!!   SYY__b.@.@ A,D!$  ! !$ '::cii.D++D,C,CD,I,/IIOO=DCIIM377399d3KSYYW,;|PSPaPabc31 2 [ ;;rOc|jd|jt|jD]\}}|jt j t jt jfvrB|jt jk(rtd|jd||jt jt jfvrtd|jd|td|jd|dg}g}g}g}g}|j} | jD]}|jt jt jt jt jfvrtd||jt j k(rt!|jt"t$j&fsJ|j(\} t#|jd kr|j|j*| zn |j} |j-| |j-| d z|j-d |j-| <|jt jk(rt!|jt.sJ|j(\} |j*| } |jj| \} }}|d kr|d zt1| |z d z t1|zz}|j-||j-t3|| d z|j-t1||j-| 6|j-| |j-||j-|ktd|j|}|rt5j.||||}|rt7j8||}|rt7j:||}|S) zEquivalent of arr[idx] implemented in terms of static :func:`lax.slice` operations. This supports only INTEGER, ELLIPSIS, and SLICE indices, and will raise a TypeError if other indices are present. Trzstatic_slice: got rz.sK(ww9??I,=,=>>Y277399CUXYCYY(sAA)anyrh)rs rMis_advanced_int_indexerz!NDIndexer.is_advanced_int_indexers" (,,( ((rOct|||S)N) x_shardingr)_index_to_gather)rrrs rM to_gatherzNDIndexer.to_gathers DZK\ ]]rOcdd}|jDcgc]}||r |jnd}}|jDcgc].}||r"td|j|jn|0}}||j |ffScc}wcc}w)Ncx|jtjtjtjfvSr)rZr*r7r?r9)rms rM is_dynamicz*NDIndexer.tree_flatten..is_dynamics( UUy(()//9;L;LM MMrOr`)rmrX)rhrYrXrZr\ri)rrrmraw_dynamic_indicesstatic_metadatas rMrzNDIndexer.tree_flattensNGK||T!jm177=TT|| LVVW=k!%%qG^__O _ = == Us B3B c |\}}t||Dcgc]*\}}||n t||j|j,}}}|||Scc}}w)Nr)r%rXrZr\)rJaux_datachildrenrir dyn_indexrKrhs rMrzNDIndexer.tree_unflattensg%E?%-h%HJ!9c 's[CGGSM^M^-__JGJ we ,,Js/A)rhIndex | tuple[Index, ...]rir[rPrvT)rrDrPNone)rPr)rPrvr)rrrPztuple[NDIndexer, Any])rr rPr )rNamedSharding | AnyrrDrP_GatherIndexer)rQrRrSrTr]rUr{rrrrrrrrrrrrrVrOrMrvrvs  -- 7 FA<U.< 9$<:@D(+/^#'^3A^>--rOrvFc Vt|||dntj||||||S)a Take elements from an array. JAX implementation of :func:`numpy.take`, implemented in terms of :func:`jax.lax.gather`. JAX's behavior differs from NumPy in the case of out-of-bound indices; see the ``mode`` parameter below. Args: a: array from which to take values. indices: N-dimensional array of integer indices of values to take from the array. axis: the axis along which to take values. If not specified, the array will be flattened before indexing is applied. mode: Out-of-bounds indexing mode, either ``"fill"`` or ``"clip"``. The default ``mode="fill"`` returns invalid values (e.g. NaN) for out-of bounds indices; the ``fill_value`` argument gives control over this value. For more discussion of ``mode`` options, see :attr:`jax.numpy.ndarray.at`. fill_value: 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. unique_indices: If True, the implementation will assume that the indices are unique after normalization of negative indices, which lets the compiler emit more efficient code during the backward pass. If set to True and normalized indices are not unique, the result is implementation-defined and may be non-deterministic. indices_are_sorted : If True, the implementation will assume that the indices are sorted in ascending order after normalization of negative indices, which can lead to more efficient execution on some backends. If set to True and normalized indices are not sorted, the output is implementation-defined. Returns: Array of values extracted from ``a``. See also: - :attr:`jax.numpy.ndarray.at`: take values via indexing syntax. - :func:`jax.numpy.take_along_axis`: take values along an axis Examples: >>> x = jnp.array([[1., 2., 3.], ... [4., 5., 6.]]) >>> indices = jnp.array([2, 0]) Passing no axis results in indexing into the flattened array: >>> jnp.take(x, indices) Array([3., 1.], dtype=float32) >>> x.ravel()[indices] # equivalent indexing syntax Array([3., 1.], dtype=float32) Passing an axis results ind applying the index to every subarray along the axis: >>> jnp.take(x, indices, axis=1) Array([[3., 1.], [6., 4.]], dtype=float32) >>> x[:, indices] # equivalent indexing syntax Array([[3., 1.], [6., 4.]], dtype=float32) Out-of-bound indices fill with invalid values. For float inputs, this is `NaN`: >>> jnp.take(x, indices, axis=0) Array([[nan, nan, nan], [ 1., 2., 3.]], dtype=float32) >>> x.at[indices].get(mode='fill', fill_value=jnp.nan) # equivalent indexing syntax Array([[nan, nan, nan], [ 1., 2., 3.]], dtype=float32) This default out-of-bound behavior can be adjusted using the ``mode`` parameter, for example, we can instead clip to the last valid value: >>> jnp.take(x, indices, axis=0, mode='clip') Array([[4., 5., 6.], [1., 2., 3.]], dtype=float32) >>> x.at[indices].get(mode='clip') # equivalent indexing syntax Array([[4., 5., 6.], [1., 2., 3.]], dtype=float32) N)unique_indicesindices_are_sorted fill_value)_takerrY)arhroutmoderrrs rMtakers4j q'4<4X^^D5I3NGY$ &&rO)rrrrr)static_argnamesc | tdtjd||\}}||j}d}nt |t j |}||dk(rEtjj} tj|dk||j|z|}n|dk(r td|dk(rRtj|tj||j|}tjj } n/|dk(rtjj"} nt%d |d t't j|} t)t j|} | |dk(r|j*dk7r t-d |S|j*dk(r<| d|t)|jz| |d zdz} tj.|d| Sd | |<tj0t3t)t5|t)t5|| zt'|j| zd z z|f|f} tj6||d| t3| | |||S)Nz0The 'out' argument to jnp.take is not supported.rrfillraisez.The 'raise' mode to jnp.take is not supported.wrapclipzInvalid mode 'z ' for np.takez4Cannot do a non-empty jnp.take() from an empty axis.r_ri offset_dimscollapsed_slice_dimsstart_index_map).N)dimension_numbers slice_sizesrrrr)NotImplementedErrorrensure_arraylikeravelr$r:rcrGatherScatterMode FILL_OR_DROP_whererirmodrrPROMISE_IN_BOUNDSCLIP ValueErrorrdrrrI full_likeGatherDimensionNumbersrfrggather)rrhrrrrrraxis_idx gather_mode index_dimsr out_shapednumss rMrrsE _ P QQ$$VQ8*!W \  AH rwwqz2H \TV^++88Kkk'A+w1B'BGLG w N OO v~jj#**Waggh6G"HIG++==K v~++00K ~dV=9 ::288G$%*RXXa[!+a||q M NN H \\QYh'$w}}*==X\]+,I ==AY //+h  ( ( 5? 5J&AGG z(AA(E FGHI#K  !% 79-$)+$6(+=* VVrOctjtj|tjr|St j |rtj||}nr:rr rrrrrr4r~r.rr)rY axis_size axis_size_vals rM_normalize_indexr;s v||E*B,>,>? L )$JJui0M,,T-D-DY-O-3\\%-@BMRZZ(),1AI3775- (@5@ ::eai !> FFrO)rrrc  "tjd||\}}|j}tj|}t j |tjstd||Ftj|dk7rd}t|j||j}d}|j} | tj|k7r:d}t|jtj||jt|| ""fd} tj|jd }t!j"||}|j"} | |jd} t!j$|| } | dk(r!t!j&| d|jS|d k(rdd lm}t-|| }|j/|| tj0 }|jdk(r#t3j2d |||jS"t5t6j8dz kDr tddj;t="Dcgc]}t6j8|c}}|dz|zdz|zdz}t3j2|||t j>j@|jStC|Dcgc]#\}}|"k(stEjF|dr"|%}}}tItjJ| |dz}g}g}g}g}g}g}g}g}d}d}t=| D]X}|"k(rt|dk7r t-|| }|jMt!jN|||jMd|jM||jM||dz }|dz }}tEjF||dr+|jM||jM| ||dz }tEjF| |dr|jM||dz }tEjF| |dr|jMdn|jMd|jM||jM||dz }|dz }[t!jP||}t!jR||} tUjVtI|tI|tI|tI|tI|}!tUjX|| |!tI||d|S||Scc}wcc}}w)a Take elements from an array. JAX implementation of :func:`numpy.take_along_axis`, implemented in terms of :func:`jax.lax.gather`. JAX's behavior differs from NumPy in the case of out-of-bound indices; see the ``mode`` parameter below. Args: a: array from which to take values. indices: array of integer indices. If ``axis`` is ``None``, must be one-dimensional. If ``axis`` is not None, must have ``a.ndim == indices.ndim``, and ``a`` must be broadcast-compatible with ``indices`` along dimensions other than ``axis``. axis: the axis along which to take values. If not specified, the array will be flattened before indexing is applied. mode: Out-of-bounds indexing mode, either ``"fill"`` or ``"clip"``. The default ``mode="fill"`` returns invalid values (e.g. NaN) for out-of bounds indices. For more discussion of ``mode`` options, see :attr:`jax.numpy.ndarray.at`. Returns: Array of values extracted from ``a``. See also: - :attr:`jax.numpy.ndarray.at`: take values via indexing syntax. - :func:`jax.numpy.take`: take the same indices along every axis slice. Examples: >>> x = jnp.array([[1., 2., 3.], ... [4., 5., 6.]]) >>> indices = jnp.array([[0, 2], ... [1, 0]]) >>> jnp.take_along_axis(x, indices, axis=1) Array([[1., 3.], [5., 4.]], dtype=float32) >>> x[jnp.arange(2)[:, None], indices] # equivalent via indexing syntax Array([[1., 3.], [5., 4.]], dtype=float32) Out-of-bound indices fill with invalid values. For float inputs, this is `NaN`: >>> indices = jnp.array([[1, 0, 2]]) >>> jnp.take_along_axis(x, indices, axis=0) Array([[ 4., 2., nan]], dtype=float32) >>> x.at[indices, jnp.arange(3)].get( ... mode='fill', fill_value=jnp.nan) # equivalent via indexing syntax Array([[ 4., 2., nan]], dtype=float32) ``take_along_axis`` is helpful for extracting values from multi-dimensional argsorts and arg reductions. For, here we compute :func:`~jax.numpy.argsort` indices along an axis, and use ``take_along_axis`` to construct the sorted array: >>> x = jnp.array([[5, 3, 4], ... [2, 7, 6]]) >>> indices = jnp.argsort(x, axis=1) >>> indices Array([[1, 2, 0], [0, 2, 1]], dtype=int32) >>> jnp.take_along_axis(x, indices, axis=1) Array([[3, 4, 5], [2, 6, 7]], dtype=int32) Similarly, we can use :func:`~jax.numpy.argmin` with ``keepdims=True`` and use ``take_along_axis`` to extract the minimum value: >>> idx = jnp.argmin(x, axis=1, keepdims=True) >>> idx Array([[1], [0]], dtype=int32) >>> jnp.take_along_axis(x, idx, axis=1) Array([[3], [2]], dtype=int32) take_along_axisz5take_along_axis indices must be of integer type, got r_z=take_along_axis indices must be 1D if axis=None, got shape {}rzBindices and arr must have the same number of dimensions; {} vs. {}c:t|}||<t|Sr)rrf)tuprlstaxis_ints rMreplacez take_along_axis..replaces s)CCM :rOTsignedone_hot)nnr>z ...b,b->...)preferred_element_typezCOne Hot indexing is only supported for up to 50 leading dimensions.zy...z,zz...->zy...) precisionr#)r_promise_in_bounds) dimension)rrroperand_batching_dimsstart_indices_batching_dimsr)rr)-rrr>r:rir r=r.r@rcr formatrr$ lax_utilsint_dtype_for_dimrrbroadcast_shapesfulljaxr!rr bool_rrdstring ascii_lettersjoinrg PrecisionHIGHESTrar definitely_equalrfr rbreshaper concatenaterr r )#rrhrrrr index_dtypermsgrankrr arr_shaperr!hotrmlabelseqrKrgather_index_shapegather_indicesrrrrr)r*dims_to_squeezenew_ijgather_indices_arrrrs# @rMrrJs`$$%6WE*!W +hhw)   ; 3 K"m% && \ www1 Kc szz), --  A D $ RWWW  NC SZZ 0!&&9 :: tT *( ++AGGDA+  $ $Wk :'ggh)aggq!)""9i8)!^ 88Iq!'' ** Yw 2G **Wirxx* 8Cvv{ ]]=#q QQ#f**+a//  O WWuXG!f**1-G HF ( V #h . 7& @B ==   --'' ww  !*) 4kfaX TMbMbcfhiMjk*kRXXi0<=D.++/ " / %! ; aH} $ $"7I6CKK1CDEU#!!%( qje1fa  y|Q /1& qje  y|Q /Q1fa   y|Q /11""5)!((+ qje1fa? D kk!_%!~C  ( (k"34/* 56 %&A B  D% -ueK6H'+|V* VV9=* VVKHls)U%#U Ucl|dkr|t|z }ttj|d||S)NrT)sparse)rdr'rrh)rirhrs rM_make_along_axis_idxrIs3 AXCJD i''d;T7 KKrO)rinplacerrcV|r tdtjd|||\}}}|}|j}||j }d}|j |j k(s&td|j d|j d tj ||j}t|j||}|j|j|| } || j|} | S#t$r'td|jd|jdwxYw) aPut values into the destination array by matching 1d index and data slices. JAX implementation of :func:`numpy.put_along_axis`. The semantics of :func:`numpy.put_along_axis` are to modify arrays in-place, which is not possible for JAX's immutable arrays. The JAX version returns a modified copy of the input, and adds the ``inplace`` parameter which must be set to `False`` by the user as a reminder of this API difference. Args: arr: array into which values will be put. indices: array of indices at which to put values. values: array of values to put into the array. axis: the axis along which to put values. If not specified, the array will be flattened before indexing is applied. inplace: must be set to False to indicate that the input is not modified in-place, but rather a modified copy is returned. mode: Out-of-bounds indexing mode. For more discussion of ``mode`` options, see :attr:`jax.numpy.ndarray.at`. Returns: A copy of ``a`` with specified entries updated. See Also: - :func:`jax.numpy.put`: put elements into an array at given indices. - :func:`jax.numpy.place`: place elements into an array via boolean mask. - :func:`jax.numpy.ndarray.at`: array updates using NumPy-style indexing. - :func:`jax.numpy.take`: extract values from an array at given indices. - :func:`jax.numpy.take_along_axis`: extract values from an array along an axis. Examples: >>> from jax import numpy as jnp >>> a = jnp.array([[10, 30, 20], [60, 40, 50]]) >>> i = jnp.argmax(a, axis=1, keepdims=True) >>> print(i) [[1] [0]] >>> b = jnp.put_along_axis(a, i, 99, axis=1, inplace=False) >>> print(b) [[10 99 20] [99 40 50]] zjax.numpy.put_along_axis cannot modify arrays in-place, because JAX arraysare immutable. Pass inplace=False to instead return an updated array.put_along_axisrzOput_along_axis arguments 'arr' and 'indices' must have same ndim. Got arr.ndim=z and indices.ndim=rzVput_along_axis argument 'values' must be broadcastable to 'indices'. Got values.shape=z and indices.shape=rK) r rrrirrc _broadcast_torIatsetr8) rrhvaluesrrJr original_axisoriginal_arr_shaperKros rMrMrMs@j N OO../?gvV#w-yy \ ))+C D W\\ !   &q*      6F SYY6# 66#;??6? -& ^^. /F -   +W]],A/ s C880D(ct|ttjfxr!t|ttj f Sr)r4r~r:r.rDr1rKs rMr6r6ps0 C#rzz* + UJsT288DT4U0UUrOct|txrO|j|jcxuxrduncxr+t|jt xr|jdk(S)N)r4r,rrrr~rUs rM_is_simple_reverse_slicerXssN S%  7 ))sxx '4 ' 7 SXXs # 7(+B8rOc|dk(ryt|r| |cxkxr|kScS tj|tj|}}|dk(r(tj |tj r|dvSy#YyxYw)NrFrV)Npromise_inbounds)r6r:rir r>r=r.)rKrrrir>s rM!_is_valid_integer_index_for_slicer[xs~ QY s 5C $  88C=&,,s"35E b[R]]5"**5 - --   s *A<<Bc.t|txr|jduxst|jxr]|jduxst|jxr6|j duxs&t|j xr|j dk(S)Nr_)r4r,rr6rrrUs rM_is_contiguous_slicer]s S%  P 99  < 1#)) < P 88t  :0: P 88t  N 1#(( ; MA QrO) out_shardingc  td|jDtdjDsyt dDryt dDryt dDrt j tj kDrytDchc]\}}t|s|c}}ttjDchc]\}\}}t|||r|}}}}tDchc]\}}t|s|}}}ttjxr t!j"j$ } t fd|D} | r|s| rytt|zt|ztk7ryrAt'j(ttfdtD|z}|s| sSj tz t+dfzz g} g} g} t-jD]2\}}t|t*rg|j|\}}}|d k(sJ| j/|| j/t1d ||z | j/|d kxs|d k~t3j4t7j8|t2j:sJt3j|d k(sJ| j/|| j/d | j/t|t<t2j:f xst?|d k5td | DrR| Dcgc] }t=|}}t|| Dcgc] \}}||z }}}tAj*|| nt| d kDrDtCjDjd}| Dcgc]}t'jF||} }tIjJj| | | tMt@jN| | }|6tQ|d}tS|||jTjV| n || |rt'jXt|Scc}}wcc}}}wcc}}wcc}wcc}}wcc}w)Nc34K|]}|jywr)rYrrms rMrz4_attempt_rewriting_take_via_slice..s /!agg /sc3<K|]}t|tywr)r4r~ras rMrz4_attempt_rewriting_take_via_slice..s 3AZ3  3sc3$K|]}|du ywrrVras rMrz4_attempt_rewriting_take_via_slice..s qd sc3K|]Q}t|tr?|j|j|jfD]}t j |Sywr)r4r,rrrr is_symbolic_dimrrmelts rMrz4_attempt_rewriting_take_via_slice..sR / Au-WWaffaff- /    c " / " /sAAc3,K|] }|tuywrr2ras rMrz4_attempt_rewriting_take_via_slice..s$1h$srUc3K|]8}|jj|dj|dfk7:yw)rr_Nr)rrmrrKs rMrz4_attempt_rewriting_take_via_slice..sB7 q6>>#))A,7Asyy|Q;OO7s>Ac3FK|]\}}|vr tdn|ywr)r,)rrmind simple_revss rMrz4_attempt_rewriting_take_via_slice..s-.As !K/d S8.s!r_rrVc3jK|]+}t|ttjfxr|dk\-ywr)r4r~r:r.ras rMrz4_attempt_rewriting_take_via_slice..s,LARZZ( ) 4a1f 4Ls13)rrTr)rallow_negative_indicesrr^axes)-rfrhrrir_canonicalize_tuple_indexrcrdrarXrr[r]r4r ArrayImplr is_single_device_shardingshardingrrr,r%rbrr:r=r r>r.r~rDrr,int_dtype_for_shaper jnp_error%_check_precondition_oob_dynamic_slicer dynamic_slicerrmesh explicit_axesr)rindexerrr^rmrlr int_indicescontiguous_slices is_shardedhas_partial_slicesrrrorrrint_start_indicessint_limit_indicesr:rK internal_dsrms` ` @rM!_attempt_rewriting_take_via_slicers  /w //# 3 3 3  C   / // $$$ $CHH# 6CX !*3Qvq#3KC3PQ+)23sCII3F)GHH~q+35c4FH+H'0~SVQ9Mc9RqSS 30E66s||DD 7$577[$6 K((3/@+AASXM  ''#u[) *C .'n. .C$ + J#((SX %+ //#')-+')C+ Cic4#u++d+eT4 QYY5!Qu -.##EAI$9: ]]6<<,bjj 99 9 XXc]b  3##sBJJ/0 0 ADqMC C  LmLL)67AQ77+./@++NO41aQOO -- ,L 9_<&++99 K )) k **rOc 0t||}|jtj|j|} t j |j| j|} |ttjd|dtj|dk7r tdt|tjtj fr|j#}| j$r t'j(| | j$} tj*| j,r"t'j.| d| j,Stj*| jjsWt1j2| | j| j4| j6|xs | j8|xs | j:||} | j<r t'j>| | j<} t'j(| | j@S)Nrz$fill_value argument to indexed get()rz5fill_value argument to indexed get() must be a scalarr)rrrr)!rrr typeofrurw_check_precondition_oob_gatherrirBconcrete_or_errorr:rcr r4r;rr<itemscalar_bool_dimsr expand_dimsis_empty_shape slice_shaper rr rgather_slice_shaperrreversed_y_dimsr newaxis_dims) rrrrrrrr parsed_idxr|ys rMrr1sg{3*  S!1!:!:3D ! F' **399g6L6LM !4AC wwza N OO*rzz8+@+@AB??$j  7334A ,,- ==AW%8%8 99   W3399 : 7 ! !7=='2L2L%?)?)?-K1K1K j  *A  7**+A G00 11rOcveZdZUded<ded<ded<ded<ded <ded <ded <ded <ded <dZded<y)rz Sequence[int]rrr!rBzslicing.GatherDimensionNumbersrrDrrrrrNzNamedSharding | Noneslice_sharding)rQrRrSr]rrVrOrMrrXsM## '' ! "!*..&-rOrrc./|j|j}tj|jDcgc].}|j t jt jhv0c}}tjtj|dk(}|j}t|jDcgc]%\}}|j t jk(s$|'}}}|j|j\}} |r|j!}g} g} g} |j#rht|jD cgc]'\}} | j t j$k7s$|| f)}}} dt|D}t'|\} } } d}d}d}g}g}g}t)j*|j,d.g}g}g}g}g}g}g}t|jD]w\}}| r|r|| dk(s|s|dk(rt/j0| }|dj,} t3j4|dj6j}!t9| }"t9|/|j;./fd|D|| z }| J|j;| |j;| |j;| |j;|!||"z }||"z }|| vr|dz }|j=d |j t jt jfvrtj>|j@dk(rt3jB|j,|drtEd|dtGjH|j@.}#|j=|#t9|f|j=||j=d|j=||dz }|j t j$k(r:|j=d|j=d|j=||dz }X|j t jJk(rtM|j@tNsJt3jP|j@|j,|\}$}%}&|j=|&|j=| |t3jB|%drt3jB|&|j,|sA|j=tGjH|$.t9|f|j=||j=|&|j=|ntSjT|$. tSjT|%. tGjV.|&zz}'|%dkr(|j=|tGjX|'d }'|j=d|j=|'t9|f|j=||j=|&|j=||dz }|dz }|dz }itEd |d |t9|dk(rtjZd . }(nt9|dk(r*|d\})}*tGj\|)|)j>f}(nzt9|}+|j=dtGj^|D)cgc]<\})}tGj`|)|tcte|||)j>z>c}})|+}(tgjhtc|tctk|tc|},|jm|}-to|tc||||,|(| | ||- Scc}wcc}}wcc} }wcc}})w)Nr_c3K|]X\}\}}|jtjtjfvr$t j |j ||fZywr)rZr*r?r7rrCrY)rrErmes rMrz#_index_to_gather..sQ !Va 9??I$5$56 6!1a(sAA rTrc3NK|]}tj|fywr)rr)rrr: start_dims rMrz#_index_to_gather..s+  # #A{ 3Y ?s"%z index is out of bounds for axis z with size 0r")r) dimensionsz$Got unsupported indexer at position z: r)spec) rrrrrrBrrrr)8rrr:nonzerorhrZr*r?r7rdiffrrar9rrrrr1r(r,rvrir_broadcast_arraysr rrurdrrbrcrYr7rIrrr5r4r,canonicalize_slicerr iotarzerosrr9broadcast_in_dimrfrgrr sortedupdater)0r|rrrK is_advancedadvanced_axes_are_contiguousnrmrx_specadvanced_indexesidx_advanced_axesx_advanced_axesdidx_without_noneadvanced_pairsx_axisy_axiscollapsed_y_axisrrrrBgather_indices_shaperrrr slice_specidx_posrYadvanced_index_arrsriaia_specrc i_convertedrr slice_sizerhgather_indices_arraygrlast_dimrrr:rs0 @@rMrrxs#   / / 1' W^WfWfgPSCGG 9J9J'KKgh+!# (<(A!B  # # %'3__` !8  !1 2GGG5'!!!$w,@(ABCv&##J/##F+! kf kf =gYb R SSiTTl A&(hht;&G >a ! DAq??1qvvi8'(H"?? ," !Q 12E%1qvv::N4OP,"  ( ( $ (O, % $$*$5. |$)# '''++%! # #Sh %m(bJ,"s%3^9 %^>3^>%_>_A_ ct|tjttj fxrtj |dk7xs&t|ttfxs|tuxs|duS)z.Helper for eliminate_deprecated_list_indexing.rN) r4r:r;r rr<rcrr,r2xs rM_should_unpack_list_indexr2sf QUH,A,AB C ggajAo ( He, - ((] ( 4i)rOc t|tsst|tr`t|ttj t jtfs,td|Dr d}t|d}t||f}|S)Nc32K|]}t|ywr)rras rMrz5eliminate_deprecated_list_indexing..Es 7a &q ) 7rzUsing a non-tuple sequence for multidimensional indexing is not allowed; use `arr[tuple(seq)]` instead of `arr[seq]`. See https://github.com/jax-ml/jax/issues/4564 for more information.zUsing a non-tuple sequence for multidimensional indexing is not allowed; use `arr[array(seq)]` instead of `arr[seq]`. See https://github.com/jax-ml/jax/issues/4564 for more information.) r4rfrr r:r;rr<rArr@)rKr;s rMrzrz9s{ C #x  eRZZ!6!6 <* 73 7 7U cNU cN Fc *rOc8 tj|}t|tjxr.t j |jtjxs(t|txr|xrtd|DS#t$rd}YwxYw)Nc3K|]H}t|xr7tjtj|tj Jywr) _is_scalarr r=r>r:r1rrs rMrz$_is_boolean_index..XsD/G?@0:!}0; Q:0;/GsAA) r rr@r4 ShapedArrayr r=r>r:r1rr)rm abstract_is rMr8r8Rsq!J Z!1!1 2 dv7H7HIYIY[][c[c7d G 4 GQG3/GDE/G,GH JsB BBc~|ytj|ry tj|S#t$rYywxYw)z)Return True if elt is a constant or None.TF)r rerr@)rgs rMrr\sA[ #t   C   s 0 <<ctj|xsIt|tjtj t fxrtj|dk(S)z#Checks if a Python or NumPy scalar.r)r:isscalarr4r;rr<r rcrs rMrresF Q RZZ!6!6>? ''!*/rOc td|D}||kDr|dk(rdnd}td|d|d|dd t|D}t|d }|Wt|d &td t t t |dtd f||z z}|d ||z||dzd z}|S||kr td f||z z}t||z}|S) zGHelper to remove Ellipsis and add in the implicit trailing slice(None).c3^K|]%}|duxs|tuxst|t 'ywr)r2r4rDrs rMrz,_canonicalize_tuple_index..ns.e\]Q$Y%V!x-%V:aQUCV Wes+-r_rYrhzToo many indices: z -dimensional array indexed with z regular rc38K|]\}}|tus|ywrrirfs rMrz,_canonicalize_tuple_index..ts @FAsxa @sNz'Multiple ellipses (...) not supported: ) rerIranextrmaprHr,rf)arr_ndimrKnum_dimensions_consumedindex_or_indicesellipsesellipsis_indexcolonss rMrrrrls&eadeex'"9Q">wI  XJ''( 2B1C1 F GGAin @($'. Hd'  3DT34H3I K MMDk^x*AA BF o~  '#nq.@.A*B BC *)Dk^x*AA BF *v C *rO)rJcLtjd|||\}}}|j}|r td|j|jk7r td|js td|js|St j |j|j|jd}t j|t|}|jj|j|dj|jS) aUpdate array elements based on a mask. JAX implementation of :func:`numpy.place`. The semantics of :func:`numpy.place` are to modify arrays in-place, which is not possible for JAX's immutable arrays. The JAX version returns a modified copy of the input, and adds the ``inplace`` parameter which must be set to `False`` by the user as a reminder of this API difference. Args: arr: array into which values will be placed. mask: boolean mask with the same size as ``arr``. vals: values to be inserted into ``arr`` at the locations indicated by mask. If too many values are supplied, they will be truncated. If not enough values are supplied, they will be repeated. inplace: must be set to False to indicate that the input is not modified in-place, but rather a modified copy is returned. Returns: A copy of ``arr`` with masked values set to entries from `vals`. See Also: - :func:`jax.numpy.put`: put elements into an array at numerical indices. - :func:`jax.numpy.ndarray.at`: array updates using NumPy-style indexing Examples: >>> x = jnp.zeros((3, 5), dtype=int) >>> mask = (jnp.arange(x.size) % 3 == 0).reshape(x.shape) >>> mask Array([[ True, False, False, True, False], [False, True, False, False, True], [False, False, True, False, False]], dtype=bool) Placing a scalar value: >>> jnp.place(x, mask, 1, inplace=False) Array([[1, 0, 0, 1, 0], [0, 1, 0, 0, 1], [0, 0, 1, 0, 0]], dtype=int32) In this case, ``jnp.place`` is similar to the masked array update syntax: >>> x.at[mask].set(1) Array([[1, 0, 0, 1, 0], [0, 1, 0, 0, 1], [0, 0, 1, 0, 0]], dtype=int32) ``place`` differs when placing values from an array. The array is repeated to fill the masked entries: >>> vals = jnp.array([1, 3, 5]) >>> jnp.place(x, mask, vals, inplace=False) Array([[1, 0, 0, 3, 0], [0, 5, 0, 0, 1], [0, 0, 3, 0, 0]], dtype=int32) placezjax.numpy.place cannot modify arrays in-place, because JAX arrays are immutable. Pass inplace=False to instead return an updated array.z)place: arr and mask must be the same sizez'Cannot place values from an empty array)rrrdroprK) rrrr rrr _tile_to_sizerdrOrPr8ri)rmaskvalsrJdatamask_arrvals_arrrhs rMrrsv"227CtL$( ^^ ( ? @@ YY(-- @ AA  > ??  K OOHNN,8==X]] [\] ^'  $ $Xs7| <(  ! % %hV % < D DTZZ PPrOcp|r tdtjd|||\}}}|j}t j|}|j r|j r |j s|St j |t|}|d} na|dk(r't j|d|j dz }d} n5|dk(r||j z}d} n|d k(r td td ||jt j||jj|| S) aH Put elements into an array at given indices. JAX implementation of :func:`numpy.put`. The semantics of :func:`numpy.put` are to modify arrays in-place, which is not possible for JAX's immutable arrays. The JAX version returns a modified copy of the input, and adds the ``inplace`` parameter which must be set to `False`` by the user as a reminder of this API difference. Args: a: array into which values will be placed. ind: array of indices over the flattened array at which to put values. v: array of values to put into the array. mode: string specifying how to handle out-of-bound indices. Supported values: - ``"clip"`` (default): clip out-of-bound indices to the final index. - ``"wrap"``: wrap out-of-bound indices to the beginning of the array. inplace: must be set to False to indicate that the input is not modified in-place, but rather a modified copy is returned. Returns: A copy of ``a`` with specified entries updated. See Also: - :func:`jax.numpy.place`: place elements into an array via boolean mask. - :func:`jax.numpy.ndarray.at`: array updates using NumPy-style indexing. - :func:`jax.numpy.take`: extract values from an array at given indices. Examples: >>> x = jnp.zeros(5, dtype=int) >>> indices = jnp.array([0, 2, 4]) >>> values = jnp.array([10, 20, 30]) >>> jnp.put(x, indices, values, inplace=False) Array([10, 0, 20, 0, 30], dtype=int32) This is equivalent to the following :attr:`jax.numpy.ndarray.at` indexing syntax: >>> x.at[indices].set(values) Array([10, 0, 20, 0, 30], dtype=int32) There are two modes for handling out-of-bound indices. By default they are clipped: >>> indices = jnp.array([0, 2, 6]) >>> jnp.put(x, indices, values, inplace=False, mode='clip') Array([10, 0, 20, 0, 30], dtype=int32) Alternatively, they can be wrapped to the beginning of the array: >>> jnp.put(x, indices, values, inplace=False, mode='wrap') Array([10, 30, 20, 0, 0], dtype=int32) For N-dimensional inputs, the indices refer to the flattened array: >>> x = jnp.zeros((3, 5), dtype=int) >>> indices = jnp.array([0, 7, 14]) >>> jnp.put(x, indices, values, inplace=False) Array([[10, 0, 0, 0, 0], [ 0, 0, 20, 0, 0], [ 0, 0, 0, 0, 30]], dtype=int32) zjax.numpy.put cannot modify arrays in-place, because JAX arrays are immutable. Pass inplace=False to instead return an updated array.putrrrr_r'rrz-The 'raise' mode to jnp.put is not supported.z1mode should be one of 'wrap' or 'clip'; got mode=rK)r rrrrrrrdrrrO unravel_indexrirP) rrlvrrJrind_arrrv_arr scatter_modes rMrrs!B ? @@))%C;/#w MMO' //! % UZZ J  ! !%W 6% \L v~nnWaA6G&L v~ G&L w M NN ID7K LL  ''; < @ @\ @ ZZrO)rhztuple[Index, ...]rir[rPrw)NNNFFN)rr!rhr!r int | Nonerrr str | NonerrDrrDrStaticScalar | NonerPr )rr)rWNN) rr!rhr!rrr&str | slicing.GatherScatterMode | NonerrrPr r)rr!rhr!rQr!rrrJrDrrrPr )rKrrPrD) rr r|rvrrr^$NamedSharding | PartitionSpec | NonerPz Array | None)rr rKrrrDrrDrrrzArrayLike | NonerrDr^rrrrPr )r|rvrrrrDrPr) rr!rr!rr!rJrDrPr r) rr!rlr!rr!rrrJrDrPr )]rT __future__r dataclassesenum functoolsrrr2typingrrcollections.abcrnumpyr:jax._srcrr r r r r rr jax._src.laxrrrr,jax._src.numpyrrrrwrrrjax._src.partition_specr jax._src.pjitrjax._src.sharding_implsrrjax._src.tree_utilrrrjax._src.typingr r!r"r# jax._src.utilr$r%r&r'r(exportEnumr*rXrr dataclassrvrjitrrrrIrMr6rXr[r]rrrrrrrrrzr8rrrrrrrVrOrMrs[ #"  "$ +-!-$!1#HWWAAWW K  0W 0Wf!*!: : ::zdD1u-u-2u-p $&*V&V& V& V&  V&  V&  V&V&$V& V&V&r _`>BEI1Va1Vh G7837&* V V V V 1 V $ V  V9VDL 45  UUU U U  U  U U U6UtV8 Q:>g g "g 0g 7g COg T tyy  % 37#'"9=!1!6!6.+ .+ ".+.+ .+ 1 .+ ! .+.+7.+.+ .+h$2N.Z.B04x#(,x#8Fx#t) 2H ,HQHQ#(HQHQVV[48V[V[-1V[=BV[V[rO