Vpf0 ?UdZddlmZddlZddlZddlmZmZddlm Z ddl Z ddl Z ddl Z ddl Z ddlmZmZmZmZmZmZmZddlmZddlZddlZddlZddlZddlmZdd lmZdd lm Z dd l!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'dd l(m)Z)ddl(m*Z*ddl(m+Z+ddl,m-Z-ddl(m.Z.ddl(m/Z/ddl(m0Z0ddl(m1Z1ddl2m3Z3ddl4m5Z5ddl6m7Z7m8Z8ddl9m:Z:m;Z;mm Z?ddl@mAZBddlCmDZDddlCmEZEddlCmFZFddlGmHZHddlImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRddlSmTZTmUZUmVZVmWZWmXZXmYZZm[Z[d D]$Z\ e j]e\d!Z^n #e_$rdZ^Y!wxYwdZ`ed"ZadԐdd*Zbd+Zcd,ZdejeZeejfZfejgZgejhZhejiZiejjZjejkZkejlZldd/ZmejnxZnZoejpxZpZqejrZrdd1ZsGd2d3etZud4Zveve)jweu<dd7ZxexejyZye0jzexe0jzZzexe0j{Z{exej|Z|exej}Z}exej~Z~exejZe0jexe0jZexe0jZexejZexejZexejZexejZexe0jZexe0jZexe0jZexe0jZexe0jZexe0jZexejZexejxZZexejxZZexejxZZexejxZZe0jejkreneZe0jej~kre~neZe0jejkreneZd%ed8<e0jejkreneZejZejZejZejZejZejZejZejZejZejZejZe0jZe0jZejZe0jZe0jZe[ZejZejZejZejZeFjejd9d9d:dd?ZeeyeeeeeeiZd@edA<e?jZddFZeFjejd9GddJZeFjejdKLeddOZeFjejdKLeddPZeFjejddTZeFjejddVZejZeFjejddWZeFjejdKLeddXZdYZe egdZ[ dddbZe edc[ddddeddhZe edc[ddddeddjZeFjej dddqZeFjej dddvZeFjej dddzZeFjej ddd}Zd~ZɐdddZeFjeeddddZ̐ddZeFjejeɬe ed[dddZΐdddZe ed[dddZАddZѐddZeddZeddZe edg[dddZeFjeje ed[ dddZdZeFjeje׬e dddZeFjejdge ed[dddddZِddZ deLdddZe edddddZ dddZݐddĄZeFjeje edŬ[ddDŽZߐdddȄZe eddddɄZdd˄Ze eddddτZdd҄Ze eddddԄZe edլ[ dd d܄Z d d dZeFjejed d d dZe ddddd dZedddd dZe ddddddZdddddZeFjej dddZ dddddZeddZeddZeFjeedddZeFjejdddZeFjejdddZ dddZeFjejeɬ ddd Zdd Zed dZed dZeddZeFjej dddZe.jde d eLeLeLdddZeFjejdge ed[dddZeZeZeFjejdgeddd ZeFjeje ddd%Ze edլ[ dd d&Zdddd d'Zdddd!d(ZeFjeje ed[dddeezfd"d+ZeeaeeaeeeafZeeeaeafd,fZGd-d.eZd#d4Zd$d7Zd%d;Zd&d<Zd'd>Z d&d?Z d(dBZ d)dFZ d&dGZ d*dJZe edKLd+dOZeFjejdP d,d-dTZeFjejdg d.d/dWZeFjeedXde ed[ddd0dYZeFjejd1d]Z dd2d^ZeFjej dd3d_ZeFjeed`dddd4daZeFjej dd5dcZeFjej dd5ddZeFjej dd5deZeFjejd6dfZeFjejdg d7d8dhZd9diZd:dlZeFjejed;dmZed<dnZeddoZed=dqZeFjejd9eɐred>dsZed<dtZ edduZ ed=dvZ eFjej d9eɐred>dwZ ed<dxZ!eddyZ!ed=dzZ!eFjej!d9eɐred>d{Z!d|Z"d}Z#e.jd~eFjej$e#d d?ddd@dZ$dAdZ%dBdZ&e.jdd9dddCdZ'eFjej(e#ddddddDdZ(eFjej)e#ddEdZ) ddddFdZ* ddddFdZ+ ddddGdZ,dAdZ- ddddHdZ. ddddIdZ/ddddJdZ0ddddJdZ1ddddJdZ2dKdZ3ddLdZ4dMdZ5eFjej6eddfdNdZ6dZ7dZ8eFjeedddddddOdZ9eFjej:eddPdZ:eFjej;edfdQdZ; dRdddSdZ< dRdTdZ=ddUdZ> d dddVdZ? d dWdZ@dXd„ZAe dYdddZdȄZBe dddd[dʄZBe d\dddd˜d[d̄ZBe dYddd]d΄ZBeFjejBdϦ dYddd]dЄZBe edѬ[ dYddd]d҄ZCeFjejD d^d_dՄZDe ed֬[ d^d_dׄZEeFjejF d`dad؄ZFe ed֬[ d`dadلZGeFjejHeɬdd9dڐdۜdbd߄ZHe-eFjejIeddZIeIjJdZKdcdZLe dddedZMeddfdZMe dddgdZMeFjejM dddgdZMddddhdZNeFjeedeedde ed[ didjdZOdRdkdZPe ed[ddldZQe ed[ddldZReFjejSdge ed[ dmdndZSdZTeTejUZUdZVddodZWddodZXddpdZYddpdZZddddqdZ[eFjej\dddrdZ\eFjej]dsdZ]eFjej^eɬe ed[ dtdudZ^eFjej_eɬddvdZ_e ed[dZ`dZaeFjejbeaddvd ZbeFjejcdwd Zcdwd Zde ed[ ddxdZe dd9ddydZfeFjejg ddzdZgeFjejhd{dZheFjejid|dZie ededddded}dZje ededddded}dZke ededddded}dZlddddd~dZm dddddeddZnGd d!ejojpZqedd"dde jrd#dd)Zsedd"dde jrd#dd,Zsdd"dde jrd#dd-ZsiZtd.Zued,d/dd3Zved,d/dd4Zvd5d/dd6Zvd7Zwe jrfdd;Zxe ededdddedd=ZyeFjejzdge ed>ddd?ZzeFjej{e ed@[ dddDZ{eFjej|eddEZ|eFjej}e edF[ ddddHZ}dddddIZ~eFjejdg d ddKZe edLdddddMZeFjejdg d ddNZe edLdddddOZdPZeFjejeddgQ d ddRZe edL[ddddSZeFjejeddgQ d ddTZe edL[ddddUZe edV[ ddddd9dWdd[ZeFjejedd\ZeFjeje ed[ddd_Ze edV[ ddddd9dWdd`Ze edadg[dddbZe edadg[dddcZe eddLddfZe edgLddhZeFjej dddjZe edk[dddlZeFjeje edm[ dddpZeFjeje edq[ dddrZ dddvZe edw[ dddxZdyZe edz[ ddd|Zdd~ZddZdZdZddZ ddZdZGddeZdZdZdZ dddZdZdZdZdZdZdZdZdZddZddZeFjejddZeFjejddZeFjejddZeFjejddZeFjejddZddZddZeFjejdKLedܐdZeFjejdKLedܐdZdddddZdddddddZeFjeje ed[ dddZeFjeje ed[dddZe eHhdddZddZddZe ed[ dddddZeFjeje ed¬[dddÄZdĐZeFjejeddȄZe edg[dd̈́ZÐdd΄ZddddфZ dddddӄZdS(a Implements the NumPy API, using the primitives in :mod:`jax.lax`. NumPy operations are implemented in Python in terms of the primitive operations in :mod:`jax.lax`. Since NumPy operations are not primitive and instead are implemented in terms of :mod:`jax.lax` operations, we do not need to define transformation rules such as gradient or batching rules. Instead, transformations for NumPy primitives can be derived from the transformation rules for the underlying :code:`lax` primitives. ) annotationsN)CallableSequence)partial)overloadAnyLiteral NamedTupleProtocolTypeVarUnion)dedent)jit)errors)lax)ShardingSingleDeviceSharding) tree_leaves tree_flattentree_map)api_util)config)core) custom_jvp) deprecations)dispatch)dtypes) xla_bridge)_ensure_index_tuple) ArrayImpl) ShapedArray ConcreteArray) _array_copy_sort_lt_comparator_sort_le_comparator PrecisionLike) xla_client) reductions)ufuncs)util) vectorize) Array ArrayLike DeprecatedArgDimSizeDuckTypedArrayDType DTypeLikeShape StaticScalar)unzip2subvalssafe_zip ceil_of_ratiopartition_listcanonicalize_axisNumpyComplexWarning)jax_cuda12_pluginz jax.jaxlibz.cuda_plugin_extensionTshapercontextstrreturn core.Shapect|ttfs>t|dddkst |dkrt j|f|St j||S)Nndimr) isinstancetuplelistgetattrrErcanonicalize_shape)r?r@s X/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/numpy/lax_numpy.pyrJrJ_sg UUDM * *3ufd##q((DKK1,<,<  "E8W 5 55  "5' 2 22aIn addition to the original NumPy arguments listed below, also supports ``precision`` for extra control over matrix-multiplication precision on supported devices. ``precision`` may be set to ``None``, which means default precision for the backend, a :class:`~jax.lax.Precision` enum value (``Precision.DEFAULT``, ``Precision.HIGH`` or ``Precision.HIGHEST``) or a tuple of two :class:`~jax.lax.Precision` enums indicating separate precision for each argument. z jax.numpyxboolc|dS |jj}n)#t$rt|jj}YnwxYwt |t S)aCheck if the input is a complex number or an array containing complex elements. JAX implementation of :func:`numpy.iscomplexobj`. The function evaluates based on input type rather than value. Inputs with zero imaginary parts are still considered complex. Args: x: input object to check. Returns: True if ``x`` is a complex number or an array containing at least one complex element, False otherwise. See Also: - :func:`jax.numpy.isrealobj` - :func:`jax.numpy.iscomplex` Examples: >>> jnp.iscomplexobj(True) False >>> jnp.iscomplexobj(0) False >>> jnp.iscomplexobj(jnp.array([1, 2])) False >>> jnp.iscomplexobj(1+2j) True >>> jnp.iscomplexobj(jnp.array([0, 1+2j])) True NF)dtypetypeAttributeErrorasarray issubdtypecomplexfloating)rMtyps rK iscomplexobjrWs^>Y 5 ',CC    !**  CCC C ) ))s #99r1c.tj|dS)NT) canonicalize)rrPrMs rK_dtyper[s ad + + ++rLcBeZdZUded<ddZdd Zdd Zdd ZddZdS) _ScalarMetaznp.dtyperPrBintc4t|jjSN)hashrPrQ)selfs rK__hash__z_ScalarMeta.__hash__s    rLotherrrNcbt|t|kp|jj|kSr`)idrPrQrbrds rK__eq__z_ScalarMeta.__eq__s' d88r%yy >> val = jnp.uint32(0xFFFFFFFF) >>> val.astype('int32') Array(-1, dtype=int32) This function clips to the values representable in the new type: >>> _convert_and_clip_integer(val, 'int32') Array(2147483647, dtype=int32) z6_convert_and_clip_integer only accepts integer dtypes.)rFr,rSrcanonicalize_dtyperTintegerrPrx _lax_constmaxiinfominclipastype)rrP val_dtypemin_valmax_vals rK_convert_and_clip_integerr&s2#u%%773<<#  #E * *% UG $ $NCIw)G)GN L M MM' 22)#) sCe 0% 2B2B2FGG H H' sCe 0% 2B2B2FGG H H' c7G $ $ + +E 2 22rL update_docargskwargsctj|i|}t|tjrM|jdkr|t } t|}n#ttf$rYnwxYw|S)NV2) r}loadrFndarrayrPviewbfloat16rSrxAssertionError)rrouts rKrrOs    #RZ    yD HHX  c CLLcc ~ &    d *sA""A65A6numpy)modulex1x2ctttj||tj|z||Sr`)wherer)lessisnanrrs rKfminr`s1 v{2r""V\"%5%55r2 > >>rLctttj||tj|z||Sr`)rr)greaterrrs rKfmaxres1 v~b"%% R(8(88"b A AArLarg1r2arg2c,tj||Sr`)rrT)rrs rKrTrTjs  4 & &&rLelementct|dr|}tj|pt j|SN __jax_array__)hasattrrris_python_scalarr}isscalar)rs rKrrnsE Wo&&&##%%G   ) ) AR[-A-AArLctj|Sr`)r result_typers rKrrvs  T ""rLc Ntjd|tjtj|drt j|Sttj |t|dtj |tj |S)Ntrunc)integralrNr)r*check_arraylikerisdtyperP lax_internalrSrrltrr)ceilfloorrZs rKrr{s}w""" ^FLOO%9::#   " "" svaAq))**FKNNFLOO L LLrLa preferred_element_type : dtype, optional If specified, accumulate results and return a result of the given data type. If not specified, the function instead follows the numpy convention of always accumulating results and returning an inexact dtype. modeop precisionpreferred_element_typestatic_argnamesyrrrr&rct|dkst|dkrt|d|tj||\}}ntj||\}}t |dkst |dkr"t|d|jd|jdtd}|dkrJtj |}t |t |kr||}}tddd}n9|d kr3t |t |kr||}}t|}|d krd g}np|d kr3|jdd z|jd|jdd zz dz fg}n7|dkr"|jddz |jddz fg}ntdtj |ddddf|ddddfd|||}|dd|fS)Nz%() only support 1-dimensional inputs.rz%: inputs cannot be empty, got shapes  and . correlateconvolvevalidrrsamefullz-mode must be one of ['full', 'same', 'valid']rrr) rE ValueErrorr*promote_dtypes_inexactpromote_dtypeslenr?slicer)conjfliprconv_general_dilated) rMrrrrr out_orderpaddingresults rK_convrs !WW\\T!WW\\ AAA B BB#  &q! , ,DAqq  q! $ $DAqVVq[[CFFaKK YYYYqwYYY Z ZZDkk); AA 1vvA adB''i Z 1vvA a QA W__hGG v~~ aagajAo!=!ABCGG v~~ Q Q/0GG D E EE  #AdD!!!m$4adAAA 6F$+y;Q S S S& 1i  rL)rrrrravctjd||tt|t||d||S)aConvolution of two one dimensional arrays. JAX implementation of :func:`numpy.convolve`. Convolution of one dimensional arrays is defined as: .. math:: c_k = \sum_j a_{k - j} v_j Args: a: left-hand input to the convolution. Must have ``a.ndim == 1``. v: right-hand input to the convolution. Must have ``v.ndim == 1``. mode: controls the size of the output. Available operations are: * ``"full"``: (default) output the full convolution of the inputs. * ``"same"``: return a centered portion of the ``"full"`` output which is the same size as ``a``. * ``"valid"``: return the portion of the ``"full"`` output which do not depend on padding at the array edges. precision: Specify the precision of the computation. Refer to :class:`jax.lax.Precision` for a description of available values. preferred_element_type: A datatype, indicating to accumulate results to and return a result with that datatype. Default is ``None``, which means the default accumulation type for the input types. Returns: Array containing the convolved result. See Also: - :func:`jax.scipy.signal.convolve`: ND convolution - :func:`jax.numpy.correlate`: 1D correlation Examples: A few 1D convolution examples: >>> x = jnp.array([1, 2, 3, 2, 1]) >>> y = jnp.array([4, 1, 2]) ``jax.numpy.convolve``, by default, returns full convolution using implicit zero-padding at the edges: >>> jnp.convolve(x, y) Array([ 4., 9., 16., 15., 12., 5., 2.], dtype=float32) Specifying ``mode = 'same'`` returns a centered convolution the same size as the first input: >>> jnp.convolve(x, y, mode='same') Array([ 9., 16., 15., 12., 5.], dtype=float32) Specifying ``mode = 'valid'`` returns only the portion where the two arrays fully overlap: >>> jnp.convolve(x, y, mode='valid') Array([16., 15., 12.], dtype=float32) For complex-valued inputs: >>> x1 = jnp.array([3+1j, 2, 4-3j]) >>> y1 = jnp.array([1, 2-3j, 4+5j]) >>> jnp.convolve(x1, y1) Array([ 3. +1.j, 11. -7.j, 15.+10.j, 7. -8.j, 31. +8.j], dtype=complex64) rrr*rrrSrrrrrs rKrrsOLz1a((( wqzz71::DZ";Q S S SSrLrctjd||tt|t||d||S)a Correlation of two one dimensional arrays. JAX implementation of :func:`numpy.correlate`. Correlation of one dimensional arrays is defined as: .. math:: c_k = \sum_j a_{k + j} \overline{v_j} where :math:`\overline{v_j}` is the complex conjugate of :math:`v_j`. Args: a: left-hand input to the correlation. Must have ``a.ndim == 1``. v: right-hand input to the correlation. Must have ``v.ndim == 1``. mode: controls the size of the output. Available operations are: * ``"full"``: output the full correlation of the inputs. * ``"same"``: return a centered portion of the ``"full"`` output which is the same size as ``a``. * ``"valid"``: (default) return the portion of the ``"full"`` output which do not depend on padding at the array edges. precision: Specify the precision of the computation. Refer to :class:`jax.lax.Precision` for a description of available values. preferred_element_type: A datatype, indicating to accumulate results to and return a result with that datatype. Default is ``None``, which means the default accumulation type for the input types. Returns: Array containing the cross-correlation result. See Also: - :func:`jax.scipy.signal.correlate`: ND correlation - :func:`jax.numpy.convolve`: 1D convolution Examples: >>> x = jnp.array([1, 2, 3, 2, 1]) >>> y = jnp.array([4, 5, 6]) Since default ``mode = 'valid'``, ``jax.numpy.correlate`` returns only the portion of correlation where the two arrays fully overlap: >>> jnp.correlate(x, y) Array([32., 35., 28.], dtype=float32) Specifying ``mode = 'full'`` returns full correlation using implicit zero-padding at the edges. >>> jnp.correlate(x, y, mode='full') Array([ 6., 17., 32., 35., 28., 13., 4.], dtype=float32) Specifying ``mode = 'same'`` returns a centered correlation the same size as the first input: >>> jnp.correlate(x, y, mode='same') Array([17., 32., 35., 28., 13.], dtype=float32) If both the inputs arrays are real-valued and symmetric then the result will also be symmetric and will be equal to the result of ``jax.numpy.convolve``. >>> x1 = jnp.array([1, 2, 3, 2, 1]) >>> y1 = jnp.array([4, 5, 4]) >>> jnp.correlate(x1, y1, mode='full') Array([ 4., 13., 26., 31., 26., 13., 4.], dtype=float32) >>> jnp.convolve(x1, y1, mode='full') Array([ 4., 13., 26., 31., 26., 13., 4.], dtype=float32) For complex-valued inputs: >>> x2 = jnp.array([3+1j, 2, 2-3j]) >>> y2 = jnp.array([4, 2-5j, 1]) >>> jnp.correlate(x2, y2, mode='full') Array([ 3. +1.j, 3.+17.j, 18.+11.j, 27. +4.j, 8.-12.j], dtype=complex64) rrrrs rKrrsO`{Aq))) wqzz71::D[";Q S S SSrL binsrange"None | Array | Sequence[ArrayLike]weightsArrayLike | Nonec4~t|trtdtjd||t |}t j|j}t|dkrt ||Stj tj |d}|(||g}t ||}t!|dkrt#d|t%t'j|dk|dd z |dt%t'j|dk|dd z|df}|Jt+|d|d|dz|S) Nz)string values for `bins` not implemented.histogram_bin_edgesrrnz$bins argument of histogram_bin_edgesrz:`range` must be either None or a sequence of scalars, got r?)rFrANotImplementedErrorr*rrSrto_inexact_dtyperP_ndimrconcrete_or_erroroperatorindexrrr?rrr(ptplinspace)rrrrarrrPbins_ints rKrrSscK I J JJ,a666 #  !#) , ,% 4[[A 4u % % %%  #HND$JLL( ] WWYY "E %u % % %% 5\\T YRWYY Z ZZ &&!+U1X^U1X F F &&!+U1X^U1X F F H%     %(E!Hhl% @ @ @@rLSequence[ArrayLike] | Nonedensity bool | Nonetuple[Array, Array]c|>!! A B BB,Q88JAw!!T5'::) AG 4 4 4' !y}$c)nnq&8' B B' Y / / 27 ; ? ? H H L& 0iJ j 6::<< /F  rLArrayLike | list[ArrayLike]3Sequence[None | Array | Sequence[ArrayLike]] | Nonetuple[Array, Array, Array]c@tjd|| t|}n#t$rd}YnwxYw|dkr|dkrt |x}}||g}t t ||g} t | ||||\} } | | d| dfS)N histogram2drrr)r*rrrxrS transpose histogramdd) rMrrrrrNx_edgesy_edgessamplehistedgess rKrrs }a+++  D AA     AAA !VVQ %Gg W D WaV__ % %&FD%'BB+$ uQxq !!s ( 77r#tuple[Array, list[Array]]c|,tjd|tj|\}netjd||t|t|ddkrt dtj||\}}t|\}}|Ft ||kst d|Drt d||fd|d| t |}||krt dt|}n#t$r ||gz}YnwxYwg} g} tj |D]} |dn|| } t|dd| f|| | |} t| |dd| fd }t|dd| f| d k|dz |}| || | td | D}d | D}t!t| |d}t#||t%j|}t)||}|t+dd fz}||}|rB||j}||z}t3|D]}||z}|| fS)Nrrz'should have one weight for each sample.c3PK|]!}|duot|ddkV"dS)Nrrr?).0rs rK zhistogramdd..s:OOAQd]?uQxx{a/?OOOOOOrLzFor sample.shape=z, range must be a sequence of z pairs or Nones; got range=z#should be a bin for each dimension.r r rc3:K|]}t|dzVdSrNrr*rs rKr,zhistogramdd..s-EEyI"EEEEEErLc,g|]}t|Srj)rr0s rK zhistogramdd..s > > > DOO > > >rLrrlength)r*rrr?rranyrHrxbuiltinsrrrrappendrGravel_multi_indexbincountmathprodreshaperrrPrix_)r#rrrrr Dnum_binsbins_per_dimensionbin_idx_by_dimbin_edges_by_dimirange_irrnbinsdedgesxyr$rnorms rKrrs2  _///)&11GFF888 W~~vrr*** @ A AA1&'BBOFG v$!Q  %jjAooOOOOOOOo !  ''amddqG#F111a4L2DQ2GRYZZI9fQQQTlAAAGF111a4LIbM17Q;HHG'"""I&&&& EE4DEEE E E% > >-= > > >&~..FCCC" "gdi&6&6 7 7 7$ u  $ E!RLL? $ d$  ;;v| $ $DDHHJJDV  dldd  s/D##D65D6zc The JAX version of this function may in some cases return a copy rather than a view of the input. axesSequence[int] | Nonectjd|2ttt dddn|}fd|D}t j|S)aS Return a transposed version of an N-dimensional array. JAX implementation of :func:`numpy.transpose`, implemented in terms of :func:`jax.lax.transpose`. Args: a: input array axes: optionally specify the permutation using a length-`a.ndim` sequence of integers ``i`` satisfying ``0 <= i < a.ndim``. Defaults to ``range(a.ndim)[::-1]``, i.e. reverses the order of all axes. Returns: transposed copy of the array. See Also: - :func:`jax.Array.transpose`: equivalent function via an :class:`~jax.Array` method. - :attr:`jax.Array.T`: equivalent function via an :class:`~jax.Array` property. - :func:`jax.numpy.matrix_transpose`: transpose the last two axes of an array. This is suitable for working with batched 2D matrices. - :func:`jax.numpy.swapaxes`: swap any two axes in an array. - :func:`jax.numpy.moveaxis`: move an axis to another position in the array. Note: Unlike :func:`numpy.transpose`, :func:`jax.numpy.transpose` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize-away such copies when possible, so this doesn't have performance impacts in practice. Examples: For a 1D array, the transpose is the identity: >>> x = jnp.array([1, 2, 3, 4]) >>> jnp.transpose(x) Array([1, 2, 3, 4], dtype=int32) For a 2D array, the transpose is a matrix transpose: >>> x = jnp.array([[1, 2], ... [3, 4]]) >>> jnp.transpose(x) Array([[1, 3], [2, 4]], dtype=int32) For an N-dimensional array, the transpose reverses the order of the axes: >>> x = jnp.zeros(shape=(3, 4, 5)) >>> jnp.transpose(x).shape (5, 4, 3) The ``axes`` argument can be specified to change this default behavior: >>> jnp.transpose(x, (0, 2, 1)).shape (3, 5, 4) Since swapping the last two axes is a common operation, it can be done via its own API, :func:`jax.numpy.matrix_transpose`: >>> jnp.matrix_transpose(x).shape (3, 5, 4) For convenience, transposes may also be performed using the :meth:`jax.Array.transpose` method or the :attr:`jax.Array.T` property: >>> x = jnp.array([[1, 2], ... [3, 4]]) >>> x.transpose() Array([[1, 3], [2, 4]], dtype=int32) >>> x.T Array([[1, 3], [2, 4]], dtype=int32) rNrcJg|]}t|t Srj_canonicalize_axisrEr*rDrs rKr2ztranspose.."s* 9 9 9a aa ) ) 9 9 9rL)r*rrHrrErr)rrJaxes_s` rKrrsqP{A&&&(, $uT!WW~~ddd# $ $ $$% 9 9 9 95 9 9 9% q%  rL permute_dimstuple[int, ...]cVtjd|tj||S)NrR)r*rrr)rrJs rKrRrR&s'~q))) q$  rLctjd|tj|}|dkrt d|gt |dz |dz |dz R}t j||S)a&Transpose the last two dimensions of an array. JAX implementation of :func:`numpy.matrix_transpose`, implemented in terms of :func:`jax.lax.transpose`. Args: x: input array, Must have ``x.ndim >= 2`` Returns: matrix-transposed copy of the array. See Also: - :attr:`jax.Array.mT`: same operation accessed via an :func:`~jax.Array` property. - :func:`jax.numpy.transpose`: general multi-axis transpose Note: Unlike :func:`numpy.matrix_transpose`, :func:`jax.numpy.matrix_transpose` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize-away such copies when possible, so this doesn't have performance impacts in practice. Examples: Here is a 2x2x2 matrix representing a batched 2x2 matrix: >>> x = jnp.array([[[1, 2], ... [3, 4]], ... [[5, 6], ... [7, 8]]]) >>> jnp.matrix_transpose(x) Array([[[1, 3], [2, 4]], [[5, 7], [6, 8]]], dtype=int32) For convenience, you can perform the same transpose via the :attr:`~jax.Array.mT` property of :class:`jax.Array`: >>> x.mT Array([[[1, 3], [2, 4]], [[5, 7], [6, 8]]], dtype=int32) matrix_transposerzBx must be at least two-dimensional for matrix_transpose; got ndim=r)r*rr}rErrrr)rMrErJs rKrVrV,sZ)1--- $ AXX \UY\\ ] ]] /5?? /D1H /dQh / /$ q$  rL)lax_description)krJrrrmrXr^tuple[int, int]ctjd|tj|dkr9t dtj|dtj||\}}t |t|}t |t|}||krt d|dz}|dkrt|S|dkrtt|||Sttt|}||||c||<||<|dkrtt|||Stt|||S) Nrot90rz]rot90 requires its first argument to have ndim at least two, but got first argument of shape z, which has ndim zAxes must be differentrr) r*rr}rErr?rOrSrrHrr)rZrXrJax1ax2perms rKr]r]asew"""WQZZ!^^ 4=?Xa[[44')wqzz44 5 55(#s3Q((#3Q((#CZZ - . ..!e!!VV 1::Avv Q c " "" d1gg  D9d3iDItCyAvv tAs||T * ** )At$$c * **rLaxisint | Sequence[int] | Nonectjd|tt|t j|S)aReverse the order of elements of an array along the given axis. JAX implementation of :func:`numpy.flip`. Args: m: Array. axis: integer or sequence of integers. Specifies along which axis or axes should the array elements be reversed. Default is ``None``, which flips along all axes. Returns: An array with the elements in reverse order along ``axis``. See Also: - :func:`jax.numpy.fliplr`: reverse the order along axis 1 (left/right) - :func:`jax.numpy.flipud`: reverse the order along axis 0 (up/down) Examples: >>> x1 = jnp.array([[1, 2], ... [3, 4]]) >>> jnp.flip(x1) Array([[4, 3], [2, 1]], dtype=int32) If ``axis`` is specified with an integer, then ``jax.numpy.flip`` reverses the array along that particular axis only. >>> jnp.flip(x1, axis=1) Array([[2, 1], [4, 3]], dtype=int32) >>> x2 = jnp.arange(1, 9).reshape(2, 2, 2) >>> x2 Array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]], dtype=int32) >>> jnp.flip(x2) Array([[[8, 7], [6, 5]], [[4, 3], [2, 1]]], dtype=int32) When ``axis`` is specified with a sequence of integers, then ``jax.numpy.flip`` reverses the array along the specified axes. >>> jnp.flip(x2, axis=[1, 2]) Array([[[4, 3], [2, 1]], [[8, 7], [6, 5]]], dtype=int32) r)r*r_fliprSr(_ensure_optional_axesrZrbs rKrr|s9pvq!!! wqzz:;DAA B BBrLrbint | tuple[int, ...] | Nonec |Itjttt t St |}tjfd|DS)NcJg|]}t|t SrjrN)r*axrZs rKr2z_flip..s*DDD'DGG44DDDrL)rrevrHrrr?rrgs` rKreresj \ 71d5U1XX//00 1 11 T " "$ DDDDtDDD E EErLcftjd|tt|dS)aReverse the order of elements of an array along axis 1. JAX implementation of :func:`numpy.fliplr`. Args: m: Array with at least two dimensions. Returns: An array with the elements in reverse order along axis 1. See Also: - :func:`jax.numpy.flip`: reverse the order along the given axis - :func:`jax.numpy.flipud`: reverse the order along axis 0 Examples: >>> x = jnp.array([[1, 2], ... [3, 4]]) >>> jnp.fliplr(x) Array([[2, 1], [4, 3]], dtype=int32) fliplrrr*rrerSrZs rKroro-,x### wqzz1  rLcftjd|tt|dS)a Reverse the order of elements of an array along axis 0. JAX implementation of :func:`numpy.flipud`. Args: m: Array with at least one dimension. Returns: An array with the elements in reverse order along axis 0. See Also: - :func:`jax.numpy.flip`: reverse the order along the given axis - :func:`jax.numpy.fliplr`: reverse the order along axis 1 Examples: >>> x = jnp.array([[1, 2], ... [3, 4]]) >>> jnp.flipud(x) Array([[3, 4], [1, 2]], dtype=int32) flipudrrprqs rKrtrtrrrLcptj|}tj|t |dS)aReturn boolean array showing where the input is complex. JAX implementation of :func:`numpy.iscomplex`. Args: x: Input array to check. Returns: A new array containing boolean values indicating complex elements. See Also: - :func:`jax.numpy.iscomplexobj` - :func:`jax.numpy.isrealobj` Examples: >>> jnp.iscomplex(jnp.array([True, 0, 1, 2j, 1+2j])) Array([False, False, False, True, True], dtype=bool) r)r)imagrnerrMrDs rK iscomplexry-( k!nn! :a## $ $$rLcptj|}tj|t |dS)aReturn boolean array showing where the input is real. JAX implementation of :func:`numpy.isreal`. Args: x: input array to check. Returns: A new array containing boolean values indicating real elements. See Also: - :func:`jax.numpy.iscomplex` - :func:`jax.numpy.isrealobj` Examples: >>> jnp.isreal(jnp.array([False, 0j, 1, 2.1, 1+2j])) Array([ True, True, True, True, False], dtype=bool) r)r)rvreqrrxs rKisrealr} rzrLdegzctj|}tj|}t|}t |t r5t t|t rVt|dkrCtj t}tj ||}tj ||}tj ||}|rtj|n|S)aReturn the angle of a complex valued number or array. JAX implementation of :func:`numpy.angle`. Args: z: A complex number or an array of complex numbers. deg: Boolean. If ``True``, returns the result in degrees else returns in radians. Default is ``False``. Returns: An array of counterclockwise angle of each element of ``z``, with the same shape as ``z`` of dtype float. Examples: If ``z`` is a number >>> z1 = 2+3j >>> jnp.angle(z1) Array(0.98279375, dtype=float32, weak_type=True) If ``z`` is an array >>> z2 = jnp.array([[1+3j, 2-5j], ... [4-3j, 3+2j]]) >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.angle(z2)) [[ 1.25 -1.19] [-0.64 0.59]] If ``deg=True``. >>> with jnp.printoptions(precision=2, suppress=True): ... print(jnp.angle(z2, deg=True)) [[ 71.57 -68.2 ] [-36.87 33.69]] r)r)realrvr[rTinexactfloatingrErrrrconvert_element_typeatan2degrees)rr~reimrPrs rKangler!sN{1~~" {1~~" **% E7 # #-H%%-*.q''Q,,  %f - -E !"e , ,B !"e , ,B 9R  &#& 2   F2rL)nrbrrprependr8cdtjd|t|}tjt j|d}tjt j|d}|dkr|S|dkrtd||jdkrtd||j}t||}g}||tjd|t|s6t|j }d||<t|t|}|t|||||tjd|t|s6t|j }d||<t|t|}|t|t|dkrt!||}t#dg|z} t#dg|z} t#dd| |<t#dd| |<t| } t| } |jt&jkr t*jn t*j} t1|D]}| || || }|S) Nrz'n' argument of jnp.diffz'axis' argument of jnp.diffrz#order must be non-negative but got z:diff requires input that is at least one dimensional; got rr)r*rrSrrrrrrErOrHr? broadcast_torGr8r concatenaterrPr}bool_r) not_equalsubtractr)rrrbrr8rndcombinedr?slice1slice2 slice1_tuple slice2_tupler_s rKrrTst vq!!! # X^Q0JKK! 6S T T$!VV JUU >1>> ? ??X]] URSUU V VV x" D" % %$( ))) ==439ooeeDkWeEll33g OOGG$$%%% //# ((( <<239ooeeDkFE%LL11f OOGFOO$$$]]Q h % %C $KK=2 & $KK=2 &q$&,tR&,v,v,900vfo" 8833a "S L 1 2 2CC *rLzUnlike NumPy's implementation of ediff1d, :py:func:`jax.numpy.ediff1d` will not issue an error if casting ``to_end`` or ``to_begin`` to the type of ``ary`` loses precision. aryto_endto_beginc tjd|t|}tj|dd|dd}|Gtjd|t tt ||j|f}|Gtjd|t |tt ||jf}|S)Nediff1drrrn)r*rravelrsubrrSrP)rrrrrs rKrrsy#&&& c # 73qrr7CH % %& H--- % B B BCCVL M MF F+++ &%ci(H(H(H"I"IJ K KF -rL edge_order) skip_params)rbrfvarargs int | NoneArray | list[Array]cf |tdtj|g|R^}d |"tt jn(tfdt |DtdkrgStfdtj Ddkrtdt|dkrdgtz}nt|d kr t|tz}nRt|tkrt|}n"td t|d | fd t|D}td kr|dn|S) Nz;The 'edge_order' argument to jnp.gradient is not supported.cttj||}|dd|ddz }|dd|ddz }t|dkr+|dd|ddz dz|z }||z}||z}nZt|dkr7t ||j|krt ddg|jz}t |||<||}ttj||}||dd|ddz z}||dd|ddz z}|dd|ddz } |dd|ddz } | | | | zzz }| | z | | zz } | | | | zzz } ||ddz| |ddzz| |ddzz}nt d t|||f|S) NrhrrrrrzaSpacing arrays must have the same length as the dimension along which the gradient is calculated.z,Spacing arrays must be 1D arrays or scalars.) rr slice_in_dimrErr?rr=r) rhrbsliced upper_edge lower_edgeinnerh_shapesliced_xdx1dx2bcs rKgradient_along_axisz%gradient..gradient_along_axissQ S%qt 4 4 4F1q! ,JD!!FF2rNN2J Aww!||vab!1!11S81.s0XX)!QV44XXXXXXrLrc3*K|] \}}|v |VdSr`rj)r*rDs axis_tuples rKr,zgradient..s+==tq!Q*______==rLrz]Shape of array too small to calculate a numerical gradient, at least 2 elements are required.?rz$Invalid number of spacing arguments z for axis=c0g|]\}}||Srjrj)r*rlrrrs rKr2zgradient..s- K K Keb!  1b ) ) K K KrL)rr*rrGrrErrr enumerater?rrHrxzip) rrbrrspacingdxa_gradrrrs @@@rKgradientrs E  +A8888+!g C C CD \uQV}}%%JJXXXX>QRV>W>WXXXXXJ__ I====y))=====AA 9 : :: \\Q"ec*oo5BB 7||q gZ (BB 7||s:&& gBB OS\\OOOOPPP K K K K Ks:r7J7J K K K&*oo**6rLc"t| S)aCheck if the input is not a complex number or an array containing complex elements. JAX implementation of :func:`numpy.isrealobj`. The function evaluates based on input type rather than value. Inputs with zero imaginary parts are still considered complex. Args: x: input object to check. Returns: False if ``x`` is a complex number or an array containing at least one complex element, True otherwise. See Also: - :func:`jax.numpy.iscomplexobj` - :func:`jax.numpy.isreal` Examples: >>> jnp.isrealobj(0) True >>> jnp.isrealobj(1.2) True >>> jnp.isrealobj(jnp.array([1, 2])) True >>> jnp.isrealobj(1+2j) False >>> jnp.isrealobj(jnp.array([0, 1+2j])) False )rWrZs rK isrealobjrs>!__ rLC)newshapeDimSize | Shape | NoneorderrDimSize | Shape | DeprecatedArgcvd}tjd|t|ts1|t dt jdtd|}~n|td | || S#t$rYnwxYwt| || S) a0 Return a reshaped copy of an array. JAX implementation of :func:`numpy.reshape`, implemented in terms of :func:`jax.lax.reshape`. Args: a: input array to reshape shape: integer or sequence of integers giving the new shape, which must match the size of the input array. If any single dimension is given size ``-1``, it will be replaced with a value such that the output has the correct size. order: ``'F'`` or ``'C'``, specifies whether the reshape should apply column-major (fortran-style, ``"F"``) or row-major (C-style, ``"C"``) order; default is ``"C"``. JAX does not support ``order="A"``. Returns: reshaped copy of input array with the specified shape. Notes: Unlike :func:`numpy.reshape`, :func:`jax.numpy.reshape` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize-away such copies when possible, so this doesn't have performance impacts in practice. See Also: - :meth:`jax.Array.reshape`: equivalent functionality via an array method. - :func:`jax.numpy.ravel`: flatten an array into a 1D shape. - :func:`jax.numpy.squeeze`: remove one or more length-1 axes from an array's shape. Examples: >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6]]) >>> jnp.reshape(x, 6) Array([1, 2, 3, 4, 5, 6], dtype=int32) >>> jnp.reshape(x, (3, 2)) Array([[1, 2], [3, 4], [5, 6]], dtype=int32) You can use ``-1`` to automatically compute a shape that is consistent with the input size: >>> jnp.reshape(x, -1) # -1 is inferred to be 6 Array([1, 2, 3, 4, 5, 6], dtype=int32) >>> jnp.reshape(x, (-1, 2)) # -1 is inferred to be 3 Array([[1, 2], [3, 4], [5, 6]], dtype=int32) The default ordering of axes in the reshape is C-style row-major ordering. To use Fortran-style column-major ordering, specify ``order='F'``: >>> jnp.reshape(x, 6, order='F') Array([1, 4, 2, 5, 3, 6], dtype=int32) >>> jnp.reshape(x, (3, 2), order='F') Array([[1, 5], [4, 3], [2, 6]], dtype=int32) For convenience, this functionality is also available via the :meth:`jax.Array.reshape` method: >>> x.reshape(3, 2) Array([[1, 2], [3, 4], [5, 6]], dtype=int32) Tr=Nzjnp.reshape received both `shape` and `newshape` arguments. Note that using `newshape` is deprecated, please only use `shape` instead.zThe newshape argument of jax.numpy.reshape is deprecated and setting it will soon raise an error. To avoid an error in the future, and to suppress this warning, please use the shape argument instead.r stacklevelzBjnp.shape requires passing a `shape` argument, but none was given.r) r*rrFr.rwarningswarnDeprecationWarningrxr=rRrS)rr?rr__tracebackhide__s rKr=r= sHy!$$$ Hm , ,   K   MFQ (((( E } J   99U%9 ( ((    D   E  / //s0B BBrT)rinlinectjd||dkrtdt|t |f|S)aFlatten array into a 1-dimensional shape. JAX implementation of :func:`numpy.ravel`, implemented in terms of :func:`jax.lax.reshape`. ``ravel(arr, order=order)`` is equivalent to ``reshape(arr, -1, order=order)``. Args: a: array to be flattened. order: ``'F'`` or ``'C'``, specifies whether the reshape should apply column-major (fortran-style, ``"F"``) or row-major (C-style, ``"C"``) order; default is ``"C"``. JAX does not support `order="A"` or `order="K"`. Returns: flattened copy of input array. Notes: Unlike :func:`numpy.ravel`, :func:`jax.numpy.ravel` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize-away such copies when possible, so this doesn't have performance impacts in practice. See Also: - :meth:`jax.Array.ravel`: equivalent functionality via an array method. - :func:`jax.numpy.reshape`: general array reshape. Examples: >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6]]) By default, ravel in C-style, row-major order >>> jnp.ravel(x) Array([1, 2, 3, 4, 5, 6], dtype=int32) Optionally ravel in Fortran-style, column-major: >>> jnp.ravel(x, order='F') Array([1, 4, 2, 5, 3, 6], dtype=int32) For convenience, the same functionality is available via the :meth:`jax.Array.ravel` method: >>> x.ravel() Array([1, 2, 3, 4, 5, 6], dtype=int32) rKz$Ravel not implemented for order='K'.)r*rrr=sizerrs rKrrksJ^w""" c\\ D E EE T!WWJ & &&rLraise multi_indexSequence[ArrayLike]dims Sequence[int]ct|t|ks*Jdt|dt|td|D}tjdg|Rd|D}|D]T}|dkrt jt |dtt|tstdU|dkr7td t||Drtd nU|d krd t||D}n4|d krdt||D}ntd|d|dkr tjd|ddz}nK|dkr2tjd|dddddzddd}ntd|dt d|r |djnt#jt&}t||D]\}} ||t)| zz}|S)aConvert multi-dimensional indices into flat indices. JAX implementation of :func:`numpy.ravel_multi_index` Args: multi_index: sequence of integer arrays containing indices in each dimension. dims: sequence of integer sizes; must have ``len(dims) == len(multi_index)`` mode: how to handle out-of bound indices. Options are - ``"raise"`` (default): raise a ValueError. This mode is incompatible with :func:`~jax.jit` or other JAX transformations. - ``"clip"``: clip out-of-bound indices to valid range. - ``"wrap"``: wrap out-of-bound indices to valid range. order: ``"C"`` (default) or ``"F"``, specify whether to assume C-style row-major order or Fortran-style column-major order. Returns: array of flattened indices See also: :func:`jax.numpy.unravel_index`: inverse of this function. Examples: Define a 2-dimensional array and a sequence of indices of even values: >>> x = jnp.array([[2., 3., 4.], ... [5., 6., 7.]]) >>> indices = jnp.where(x % 2 == 0) >>> indices (Array([0, 0, 1], dtype=int32), Array([0, 2, 1], dtype=int32)) >>> x[indices] Array([2., 4., 6.], dtype=float32) Compute the flattened indices: >>> indices_flat = jnp.ravel_multi_index(indices, x.shape) >>> indices_flat Array([0, 2, 4], dtype=int32) These flattened indices can be used to extract the same values from the flattened ``x`` array: >>> x_flat = x.ravel() >>> x_flat Array([2., 3., 4., 5., 6., 7.], dtype=float32) >>> x_flat[indices_flat] Array([2., 4., 6.], dtype=float32) The original indices can be recovered with :func:`~jax.numpy.unravel_index`: >>> jnp.unravel_index(indices_flat, x.shape) (Array([0, 0, 1], dtype=int32), Array([0, 2, 1], dtype=int32)) zlen(multi_index)=z != len(dims)=c3VK|]$}tjtj|dV%dS)z*in `dims` argument of ravel_multi_index().Nrrrrr*ds rKr,z$ravel_multi_index..s5uuklt%hna9effuuuuuurLr9c,g|]}t|SrjrSr*rDs rKr2z%ravel_multi_index..s555AWQZZ555rLrzxThe error occurred because ravel_multi_index was jit-compiled with mode='raise'. Use mode='wrap' or mode='clip' instead.zonly int indices permittedc3ZK|]&\}}tj|dk||kzV'dSrNr(r6r*rDrs rKr,z$ravel_multi_index..s= U U$!Q:>1q5Q!V, - - U U U U U UrLz"invalid entry in coordinates arrayrc<g|]\}}t|d|dz SrY)rrs rKr2z%ravel_multi_index..s,PPPTQtAq!a%((PPPrLwrapcg|] \}}||z Srjrjrs rKr2z%ravel_multi_index..s DDDAq1uDDDrLz invalid mode=z%. Expected 'raise', 'wrap', or 'clip'FrNrrrzinvalid order=z. Expected 'C' or 'F'rrn)rrGr*rrrarrayrTr[rrxr6rrr}cumprodrPrrint_r^) rrrrmulti_index_arrrstridesrrDrs rKr9r9sp [  SYY & & &(gC >> x = jnp.array([2., 3., 4., 5., 6., 7.]) >>> indices = jnp.array([1, 3, 5]) >>> print(x[indices]) [3. 5. 7.] Now if ``x`` is reshaped, ``unravel_indices`` can be used to convert the flat indices into a tuple of indices that access the same entries: >>> shape = (2, 3) >>> x_2D = x.reshape(shape) >>> indices_2D = jnp.unravel_index(indices, shape) >>> indices_2D (Array([0, 1, 1], dtype=int32), Array([1, 0, 2], dtype=int32)) >>> print(x_2D[indices_2D]) [3. 5. 7.] The inverse function, ``ravel_multi_index``, can be used to obtain the original indices: >>> jnp.ravel_multi_index(indices_2D, shape) Array([1, 3, 5], dtype=int32) unravel_indexc3<K|]}t|dkVdSrrE)r*rs rKr,z unravel_index../s,%%!aA%%%%%%rLz7unravel_index: shape should be a scalar or 1D sequence.rrc 3dK|]*\}}t|dz td|V+dS)rrNr)r*rrDoob_negoob_poss rKr,z unravel_index..6sW991aWa!eU7Aq%9%9::999999rL)r*rrSrHrxr6rrreversedrr)divmodrGr7)rr? indices_arr out_indicesrDrrrs @@rKrrsGT000  + KKEE GEEE %%u%%%%%P N O OO"#s5zz!1+tIe,,--..@@da"(- Q"?"?KQ !O' " ' 99999#E;77999 9 99s8 AA) new_shaperctjd|t|}td|Drt dt |}t j|}|jdks|dkrt||St||j}t||d|}t||S)Nresizec3"K|] }|dkV dSrrj)r* dim_lengths rKr,zresize..?s&44Ja444444rLz0all elements of `new_shape` must be non-negativerr)) r*rrr6rrr;r<r zeros_liker8tiler=)rrrnew_sizerepeatss rKrr9sx###!),,)44)44444I G H HH a# Yy ! !(X]]h!mm c + + ++ (CH - -' S'9H9%# i  rLctjd|tt||t |ndS)a>Remove one or more length-1 axes from array JAX implementation of :func:`numpy.sqeeze`, implemented via :func:`jax.lax.squeeze`. Args: a: input array axis: integer or sequence of integers specifying axes to remove. If any specified axis does not have a length of 1, an error is raised. If not specified, squeeze all length-1 axes in ``a``. Returns: copy of ``a`` with length-1 axes removed. Notes: Unlike :func:`numpy.squeeze`, :func:`jax.numpy.squeeze` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize-away such copies when possible, so this doesn't have performance impacts in practice. See Also: - :func:`jax.numpy.expand_dims`: the inverse of ``squeeze``: add dimensions of length 1. - :meth:`jax.Array.squeeze`: equivalent functionality via an array method. - :func:`jax.lax.squeeze`: equivalent XLA API. - :func:`jax.numpy.ravel`: flatten an array into a 1D shape. - :func:`jax.numpy.reshape`: general array reshape. Examples: >>> x = jnp.array([[[0]], [[1]], [[2]]]) >>> x.shape (3, 1, 1) Squeeze all length-1 dimensions: >>> jnp.squeeze(x) Array([0, 1, 2], dtype=int32) >>> _.shape (3,) Equivalent while specifying the axes explicitly: >>> jnp.squeeze(x, axis=(1, 2)) Array([0, 1, 2], dtype=int32) Attempting to squeeze a non-unit axis results in an error: >>> jnp.squeeze(x, axis=0) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ValueError: cannot select an axis to squeeze out which has size not equal to one, got shape=(3, 1, 1) and dimensions=(0,) For convenience, this functionality is also available via the :meth:`jax.Array.squeeze` method: >>> x.squeeze() Array([0, 1, 2], dtype=int32) squeezeN)r*r_squeezerSrrrbs rKrrNsBpy!$$$ '!**4;K1$777QU V VVrLc|Xt|}tj|stdt dt |D}t j||S)NzCjnp.squeeze with axis=None is not supported with shape polymorphismc3,K|]\}}|dk |VdSr.rjrs rKr,z_squeeze..s*<>> x = jnp.array([1, 2, 3]) >>> x.shape (3,) Expand the leading dimension: >>> jnp.expand_dims(x, 0) Array([[1, 2, 3]], dtype=int32) >>> _.shape (1, 3) Expand the trailing dimension: >>> jnp.expand_dims(x, 1) Array([[1], [2], [3]], dtype=int32) >>> _.shape (3, 1) Expand multiple dimensions: >>> jnp.expand_dims(x, (0, 1, 3)) Array([[[[1], [2], [3]]]], dtype=int32) >>> _.shape (1, 1, 3, 1) Dimensions can also be expanded more succinctly by indexing with ``None``: >>> x[None] # equivalent to jnp.expand_dims(x, 0) Array([[1, 2, 3]], dtype=int32) >>> x[:, None] # equivalent to jnp.expand_dims(x, 1) Array([[1], [2], [3]], dtype=int32) >>> x[None, None, :, None] # equivalent to jnp.expand_dims(x, (0, 1, 3)) Array([[[[1], [2], [3]]]], dtype=int32) expand_dims)r*rrrrr s rKrrs7B}a((( T " "$ D ! !!rL)axis1axis2rrctjd|tjt |}||||c||<||<t j|t|S)aSwap two axes of an array. JAX implementation of :func:`numpy.swapaxes`, implemented in terms of :func:`jax.lax.transpose`. Args: a: input array axis1: index of first axis axis2: index of second axis Returns: Copy of ``a`` with specified axes swapped. Notes: Unlike :func:`numpy.swapaxes`, :func:`jax.numpy.swapaxes` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize away such copies when possible, so this doesn't have performance impacts in practice. See Also: - :func:`jax.numpy.moveaxis`: move a single axis of an array. - :func:`jax.numpy.rollaxis`: older API for ``moveaxis``. - :func:`jax.lax.transpose`: more general axes permutations. - :meth:`jax.Array.swapaxes`: same functionality via an array method. Examples: >>> a = jnp.ones((2, 3, 4, 5)) >>> jnp.swapaxes(a, 1, 3).shape (2, 5, 4, 3) Equivalent output via the ``swapaxes`` array method: >>> a.swapaxes(1, 3).shape (2, 5, 4, 3) Equivalent output via :func:`~jax.numpy.transpose`: >>> a.transpose(0, 3, 2, 1).shape (2, 5, 4, 3) swapaxes)r*rr}arangerErrrH)rrrras rKrrsaRz1%%% 477  $!%[$u+$u+tE{ q$t** % %%rLsource destinationctjd|tt|t |t |S)aMove an array axis to a new position JAX implementation of :func:`numpy.moveaxis`, implemented in terms of :func:`jax.lax.transpose`. Args: a: input array source: index or indices of the axes to move. destination: index or indices of the axes destinations Returns: Copy of ``a`` with axes moved from ``source`` to ``destination``. Notes: Unlike :func:`numpy.moveaxis`, :func:`jax.numpy.moveaxis` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize away such copies when possible, so this doesn't have performance impacts in practice. See also: - :func:`jax.numpy.swapaxes`: swap two axes. - :func:`jax.numpy.rollaxis`: older API for moving an axis. - :func:`jax.numpy.transpose`: general axes permutation. Examples: >>> a = jnp.ones((2, 3, 4, 5)) Move axis ``1`` to the end of the array: >>> jnp.moveaxis(a, 1, -1).shape (2, 4, 5, 3) Move the last axis to position 1: >>> jnp.moveaxis(a, -1, 1).shape (2, 5, 3, 4) Move multiple axes: >>> jnp.moveaxis(a, (0, 1), (-1, -2)).shape (4, 5, 3, 2) This can also be accomplished via :func:`~jax.numpy.transpose`: >>> a.transpose(2, 3, 1, 0).shape (4, 5, 3, 2) moveaxis)r*r _moveaxisrSr)rrrs rKrr sH`z1%%% 71::26::&{33 5 55rL)rrctfdDtfd|D}tt|kr=tdtt|fdt t D}t t|D]\}}|||tj |S)Nc3RK|]!}t|tV"dSr`rNrPs rKr,z_moveaxis..?s4@@A#AtAww//@@@@@@rLc3RK|]!}t|tV"dSr`rNrPs rKr,z_moveaxis..@s4JJ(DGG44JJJJJJrLz)Inconsistent number of elements: {} vs {}cg|]}|v| Srjrj)r*rDrs rKr2z_moveaxis..Ds 7 7 7q!rL) rGrrformatrrEsortedrinsertrr)rrrradestsrcs`` rKrr=s @@@@@@@ @ @&JJJJkJJJJJ+[[C $$$$ @fS[[#k*:*:;; = == 7 7 7 7U477^^ 7 7 7$#k62233idCKKc q$  rL) equal_nanh㈵>:0yE>rrtolatolr%c (tjd||\}}t|}tj|tjrt j||Stjd||\}}t|}t |trtj |}t j ||}t j ||}t j t j t j||t j|t j|t j |}t#j|}t#j|}t#j||} t#j||} t#j|t#j| }t j||} t#j| | } t#j|| }t#j|} t#j|}t#j| |}t#j|t#j|}|r*t#j| |}t#j||}|S)a(Check if the elements of two arrays are approximately equal within a tolerance. JAX implementation of :func:`numpy.allclose`. Essentially this function evaluates the following condition: .. math:: |a - b| \le \mathtt{atol} + \mathtt{rtol} * |b| ``jnp.inf`` in ``a`` will be considered equal to ``jnp.inf`` in ``b``. Args: a: first input array to compare. b: second input array to compare. rtol: relative tolerance used for approximate equality. Default = 1e-05. atol: absolute tolerance used for approximate equality. Default = 1e-08. equal_nan: Boolean. If ``True``, NaNs in ``a`` will be considered equal to NaNs in ``b``. Default is ``False``. Returns: A new array containing boolean values indicating whether the input arrays are element-wise approximately equal within the specified tolerances. See Also: - :func:`jax.numpy.allclose` - :func:`jax.numpy.equal` Examples: >>> jnp.isclose(jnp.array([1e6, 2e6, jnp.inf]), jnp.array([1e6, 2e7, jnp.inf])) Array([ True, False, True], dtype=bool) >>> jnp.isclose(jnp.array([1e6, 2e6, 3e6]), ... jnp.array([1.00008e6, 2.00008e7, 3.00008e8]), rtol=1e3) Array([ True, True, True], dtype=bool) >>> jnp.isclose(jnp.array([1e6, 2e6, 3e6]), ... jnp.array([1.00001e6, 2.00002e6, 3.00009e6]), atol=1e3) Array([ True, True, True], dtype=bool) >>> jnp.isclose(jnp.array([jnp.nan, 1, 2]), ... jnp.array([jnp.nan, 1, 2]), equal_nan=True) Array([ True, True, True], dtype=bool) isclose)r* promote_argsr[rrTrrr|promote_args_inexactrU_complex_elem_typerleabsrrmulr)isinf logical_or logical_and logical_notr)rrr(r)r%rPra_infb_infany_infboth_inf same_valuesame_infa_nanb_nanany_nanboth_nans rKr+r+JsX  9a + +$!Q ))% ufo.. 6!Q<< "9a 3 3$!Q ))%''+  #E * *E !$ . .$ !$ . .$ GCGAqMMGD#'$ ++,, . .# ,q//% ,q//%  eU + +'  u - -(3 27 ; ;<<#va||*  * 5 5(#x((# ,q//% ,q//%  eU + +'3 27 ; ;<<#+!%//H  C * *C *rLxpfpleftArrayLike | str | Noner periodc rtjd|||t|t|kst|dkrt dtj||\}}tj|\}~~~t |tr|dkrt d|d} nd} t |tr|dkrt d|d} nd} tj |j tj rt d |t|d krt d |tj|}||z}||z}tj||\}}t#|d d|z ||dd|zg}t#|d d||ddg}t%t'||d dt)|dz } || || dz z } || || dz z } ||| dz z }tjtj|j j}tj| |k}t1||| dz || dz |t1|d| z | zz}| s@t |trJ||d n|}|t1||d k||}| s@t |trJ||d n|}|t1||d k||}|S)Ninterprz6xp and fp must be one-dimensional arrays of equal size extrapolatezAthe only valid string value of `left` is 'extrapolate', but got: TFzBthe only valid string value of `right` is 'extrapolate', but got: z+jnp.interp: complex x values not supported.rzperiod must be a scalar; got rr r )r*rr?rErrrFrArrTrPr}rUr)r0r sort_key_valrrrrrfinfoepsr)rMr@rArBr rDx_arrxp_arrfp_arrextrapolate_leftextrapolate_rightrDdfrdeltaepsilondx0rleft_arr right_arrs rK_interprVstxB+++ 2YY%))tBxx1}} M N NN-a44-%  ' + +'&Rc } ;26;; < <<s  <27<< = == u{B$677D B C CC  F||q ?v?? @ @@ Z  F FNE f_F%ff55NFF &+.rr V8KL M MF &+vvbqbz: ; ;F <G 4 4 4aVqII! ay6!a%= " ay6!a%= " &Q- % Jrx --1 2 2'  w# CAq1u sAr9J9J1Jb0P PQQ! 0$$$$$$'+|&))H ~ q !8Q / /a 2%%%%%%).6"::EI ~ r "Iq 1 1a (rLz In addition to constant interpolation supported by NumPy, jnp.interp also supports left='extrapolate' and right='extrapolate' to indicate linear extrapolation instead.c0g}t|ts||dt|ts||d||dtt|}|||||||S)NrBr rDr)rFrAr8rrV)rMr@rArBr rDr jitted_interps rKrFrFs/c#dl6"""s$u}7### ^8$$$g???- q"b$v 6 66rLr fill_value condition Literal[None]rrZ(None | ArrayLike | tuple[ArrayLike, ...]cdSr`rjr[rMrrrZs rKrrs #&#rLcdSr`rjr_s rKrrs crLArray | tuple[Array, ...]cdSr`rjr_s rKrrs +.#rLc |)|'tjd|t|||Stjd|||||td||td|d|dtj|||S)a Select elements from two arrays based on a condition. JAX implementation of :func:`numpy.where`. .. note:: when only ``condition`` is provided, ``jnp.where(condition)`` is equivalent to ``jnp.nonzero(condition)``. For that case, refer to the documentation of :func:`jax.numpy.nonzero`. The docstring below focuses on the case where ``x`` and ``y`` are specified. The three-term version of ``jnp.where`` lowers to :func:`jax.lax.select`. Args: condition: boolean array. Must be broadcast-compatible with ``x`` and ``y`` when they are specified. x: arraylike. Should be broadcast-compatible with ``condition`` and ``y``, and typecast-compatible with ``y``. y: arraylike. Should be broadcast-compatible with ``condition`` and ``x``, and typecast-compatible with ``x``. size: integer, only referenced when ``x`` and ``y`` are ``None``. For details, see :func:`jax.numpy.nonzero`. fill_value: only referenced when ``x`` and ``y`` are ``None``. For details, see :func:`jax.numpy.nonzero`. Returns: An array of dtype ``jnp.result_type(x, y)`` with values drawn from ``x`` where ``condition`` is True, and from ``y`` where condition is ``False. If ``x`` and ``y`` are ``None``, the function behaves differently; see `:func:`jax.numpy.nonzero` for a description of the return type. See Also: - :func:`jax.numpy.nonzero` - :func:`jax.numpy.argwhere` - :func:`jax.lax.select` Notes: Special care is needed when the ``x`` or ``y`` input to :func:`jax.numpy.where` could have a value of NaN. Specifically, when a gradient is taken with :func:`jax.grad` (reverse-mode differentiation), a NaN in either ``x`` or ``y`` will propagate into the gradient, regardless of the value of ``condition``. More information on this behavior and workarounds is available in the `JAX FAQ `_. Examples: When ``x`` and ``y`` are not provided, ``where`` behaves equivalently to :func:`jax.numpy.nonzero`: >>> x = jnp.arange(10) >>> jnp.where(x > 4) (Array([5, 6, 7, 8, 9], dtype=int32),) >>> jnp.nonzero(x > 4) (Array([5, 6, 7, 8, 9], dtype=int32),) When ``x`` and ``y`` are provided, ``where`` selects between them based on the specified condition: >>> jnp.where(x > 4, x, 0) Array([0, 0, 0, 0, 0, 5, 6, 7, 8, 9], dtype=int32) NrrYzJsize and fill_value arguments cannot be used in three-term where function.z[Either both or neither of the x and y arguments should be provided to jax.numpy.where, got rr)r*rnonzeror_wherer_s rKrrsxY19),,, 94J ? ? ??)Q222 :1 4 5 55yAI '''"#''' ( (( ;y!Q ' ''rLcondlist choicelistdefaultct|t|kr?d}t|t|t|t|dkrtdtj|g|R}t t dg|R}t|td}tj t |g|RS)Nz8condlist must have length equal to choicelist ({} vs {})rzcondlist must be non-emptyFrh) rrr r*rstackbroadcast_arraysargmaxrrNrselect_n)rfrgrhmsg conditionsidxs rKselectrqLs  ]]c*oo%% DC SZZH s:?? @ @@]]a 1 2 22"78Z888*%e7h77788*z  &&Q///# '9j999 ::rLr4 minlengthr5c6tjd|tt|tst dt|t |dkrtdtj tj |d}|Utj t|d}t||jo#t| dz}ntj|d}|t#jdt& }n/t)|t)|krtd t+|t|jt/|d |S) anCount the number of occurrences of each value in an integer array. JAX implementation of :func:`numpy.bincount`. For an array of positive integers ``x``, this function returns an array ``counts`` of size ``x.max() + 1``, such that ``counts[i]`` contains the number of occurrences of the value ``i`` in ``x``. The JAX version has a few differences from the NumPy version: - In NumPy, passing an array ``x`` with negative entries will result in an error. In JAX, negative values are clipped to zero. - JAX adds an optional ``length`` parameter which can be used to statically specify the length of the output array so that this function can be used with transformations like :func:`jax.jit`. In this case, items larger than `length + 1` will be dropped. Args: x : N-dimensional array of positive integers weights: optional array of weights associated with ``x``. If not specified, the weight for each entry will be ``1``. minlength: the minimum length of the output counts array. length: the length of the output counts array. Must be specified statically for ``bincount`` to be used with :func:`jax.jit` and other JAX transformations. Returns: An array of counts or summed weights reflecting the number of occurrences of values in ``x``. See Also: - :func:`jax.numpy.histogram` - :func:`jax.numpy.digitize` - :func:`jax.numpy.unique_counts` Examples: Basic bincount: >>> x = jnp.array([1, 1, 2, 3, 3, 3]) >>> jnp.bincount(x) Array([0, 2, 1, 3], dtype=int32) Weighted bincount: >>> weights = jnp.array([1, 2, 3, 4, 5, 6]) >>> jnp.bincount(x, weights) Array([ 0, 3, 3, 15], dtype=int32) Specifying a static ``length`` makes this jit-compatible: >>> jit_bincount = jax.jit(jnp.bincount, static_argnames=['length']) >>> jit_bincount(x, length=5) Array([0, 2, 1, 3, 0], dtype=int32) Any negative numbers are clipped to the first bin, and numbers beyond the specified ``length`` are dropped: >>> x = jnp.array([-1, -1, 1, 3, 10]) >>> jnp.bincount(x, length=5) Array([2, 1, 0, 1, 0], dtype=int32) r:z6x argument to bincount must have an integer type; got rz#only 1-dimensional input supported.zCThe error occurred because of argument 'minlength' of jnp.bincount.NzqThe error occurred because of argument 'x' of jnp.bincount. To avoid this error, pass a static `length` argument.z@The error occurred because of argument 'length' of jnp.bincount.rnz'shape of weights must match shape of x.r)r*rrTr[rrxrErrrrrrSrrr^concrete_dim_or_errorr}rrr?rrrr)rMrrrr5rKs rKr:r:_sg|z1%%% F1IIw ' 'Z XVTUYYXX Y YY !WW\\ : ; ;;$X^YKMM) ^  "7A> ? ?EEJ?3uyy{{+;+;a+? @ @FF  'JLLF _hq%%%GG Qxx5>>!! > ? ?? vvg ' ' *41:: 6 : :7 C CCrLshapescdSr`rjrus rKbroadcast_shapesrxsADrLSequence[int | core.Tracer]tuple[int | core.Tracer, ...]cdSr`rjrws rKrxrxs9<rLrxc>|sdSd|D}tj|S)Nrjcbg|],}tj|dkr|fnt|-Sr)r}rErG)r*r?s rKr2z$broadcast_shapes..s6 R R R%!++UHHu R R RrL)rrxrws rKrxrxs0  2 R R6 R R R& v &&rLzAThe JAX version does not necessarily return a view of the input. list[Array]ctj|Sr`)r*_broadcast_arraysrs rKrkrks   &&rLrDimSize | Shapec,tj||Sr`)r* _broadcast_to)rr?s rKrrs  E5 ) ))rLindices_or_sectionsint | Sequence[int] | ArrayLikec tjttjt jddj}t|ttfs,t|tj tfr1|jdkr&fd|D}dgt|z|gz}ntj|rt!ddtjt"|dd}t%||\ dkr fdt'|d zD}nWd kr? fd t' d zD fd t'| z Dz}nt!d d|D}dgtztc d fdt)|dd|d dDS)N in jax.numpy.z argument `axis`rcBg|]}tj|ddS)r argument 1)rrt)r*i_srs rKr2z_split..sB(((  "3(G(G(G(GHH(((rLz jax.numpy.z4 with a symbolic number of sections is not supportedrcg|]}|zSrjrjr*rD part_sizes rKr2z_split..s-9999}999rLr array_splitc g|] }|dzz Srrjrs rKr2z_split..s"333i!m 333rLc8g|]}|zdzdzzdz zSrrj)r*rDrr+s rKr2z_split..sD + + +  Y1q5Y]3a7 8 + + +rLz:array split does not result in an equal division: rest is cbg|],}tj|r|ntj|-Srj)ris_symbolic_dimr}int64rs rKr2z_split..sD+++,Q//@11RXa[[+++rLc(t|||fgSr`)r6)rMrDrs rKz_split..sGAAx00rLc ng|]1\}}tj||2Srj)rr)r*startend_subvalrrbendsstartss rKr2z_split..s] H H HeS )Cu55wwtT37O7O P P H H HrLr)r*rrSrrrrr?rFrGrHr}rr,rErrr^rrr) rrrrbr split_indices num_sectionsrrrr+rs `` ` @@@@@rK_splitrsr3 # 6Zb6Z6Z6Z [ [$ 4$$udm44Y$rz5&9::Y""((((&(((C$2333tf.fs[ S!!! A qyyS\\Q&& d "c.T : : ::rL)rr-rrrBr)r* implementsrIr})rrbrs`` rK_split_on_axisrsP?72r??u555;;;;;;65; (rLvsplithsplitdsplitrc(td|||S)Nrrhrrs rKrr s  s$7d C C CCrLjax-numpy-clip-complex)ra_mina_maxrrrArrayLike | DeprecatedArgr ArrayLike | None | DeprecatedArgrc4t|ts|n|}|tdt|ts|n|}t|ts|n|}td|||fDrt jdt dtjd|td|||fDrtjd d d|tj ||}|tj ||}t|S) apClip array values to a specified range. JAX implementation of :func:`numpy.clip`. Args: arr: N-dimensional array to be clipped. min: optional minimum value of the clipped range; if ``None`` (default) then result will not be clipped to any minimum value. If specified, it should be broadcast-compatible with ``arr`` and ``max``. max: optional maximum value of the clipped range; if ``None`` (default) then result will not be clipped to any maximum value. If specified, it should be broadcast-compatible with ``arr`` and ``min``. a: deprecated alias of the ``arr`` argument. Will result in a :class:`DeprecationWarning` if used. a_min: deprecated alias of the ``min`` argument. Will result in a :class:`DeprecationWarning` if used. a_max: deprecated alias of the ``max`` argument. Will result in a :class:`DeprecationWarning` if used. Returns: An array containing values from ``arr``, with values smaller than ``min`` set to ``min``, and values larger than ``max`` set to ``max``. See also: - :func:`jax.numpy.minimum`: Compute the element-wise minimum value of two arrays. - :func:`jax.numpy.maximum`: Compute the element-wise maximum value of two arrays. Examples: >>> arr = jnp.array([0, 1, 2, 3, 4, 5, 6, 7]) >>> jnp.clip(arr, 2, 5) Array([2, 2, 2, 3, 4, 5, 5, 5], dtype=int32) Nz+No input was provided to the clip function.c3BK|]}t|t VdSr`)rFr.r*ts rKr,zclip..B s/EEaZ= ) ) )EEEEEErLzPassing arguments 'a', 'a_min' or 'a_max' to jax.numpy.clip is deprecated. Please use 'arr', 'min' or 'max' respectively instead.rrrc3TK|]#}tj|V$dSr`)jaxrrWrs rKr,zclip..K s2<3#}55>3#EEAue3DEEEEE MK vs###<._round_floati s1}} Yq#,< = == 49BJ3F3F BJ///AA 2> * *F '#)CGAv...>@@AG I IC38BJ3F3F3 #C / / /COrLrMr-rBr,)r*rrrrrrr[rTrrSrUrcomplexrrv)rrrrrPs ` @rKrr[ s w"""  #HNH>` a a(_ Q R RR ))%w!|| ; = == 1:: P P P P P P P'' ;||CHQKK00,,sx{{2K2K L LL <??rLctjd||tdt|d}t t j||tj|tj |S)Nfixz/The 'out' argument to jnp.fix is not supported.r) r*rrrrrger)rr)rMrzeros rKrr sfua   _ O P PP Aq  $ sva QQ @ @@rLnanposinfneginfc ~tjd|t|}t|tst |St|t r[tjttj ||||ttj ||||Sttj|}||jn|}||jn|}t#t%j|t |||}t#t%j|t |||}t#t%j|t |||}|S)N nan_to_num)rrrrn)r*rr[rTrrSrUrrrrrvrIrrrrrr)risposinfisneginf)rMrrrrrPinfors rKrr sX  |Q''' ))% E7 # # 1::''F ;!#fVDDD!#fVDDD F FF v(// 0 0$~4886&~4886& fl1oows%888!<<# foc""GF%$@$@$@#FF# foc""GF%$@$@$@#FF# *rLc xtjd||tjt |||||S)aCheck if two arrays are element-wise approximately equal within a tolerance. JAX implementation of :func:`numpy.allclose`. Essentially this function evaluates the following condition: .. math:: |a - b| \le \mathtt{atol} + \mathtt{rtol} * |b| ``jnp.inf`` in ``a`` will be considered equal to ``jnp.inf`` in ``b``. Args: a: first input array to compare. b: second input array to compare. rtol: relative tolerance used for approximate equality. Default = 1e-05. atol: absolute tolerance used for approximate equality. Default = 1e-08. equal_nan: Boolean. If ``True``, NaNs in ``a`` will be considered equal to NaNs in ``b``. Default is ``False``. Returns: Boolean scalar array indicating whether the input arrays are element-wise approximately equal within the specified tolerances. See Also: - :func:`jax.numpy.isclose` - :func:`jax.numpy.equal` Examples: >>> jnp.allclose(jnp.array([1e6, 2e6, 3e6]), jnp.array([1e6, 2e6, 3e7])) Array(False, dtype=bool) >>> jnp.allclose(jnp.array([1e6, 2e6, 3e6]), ... jnp.array([1.00008e6, 2.00008e7, 3.00008e8]), rtol=1e3) Array(True, dtype=bool) >>> jnp.allclose(jnp.array([1e6, 2e6, 3e6]), ... jnp.array([1.00001e6, 2.00002e6, 3.00009e6]), atol=1e3) Array(True, dtype=bool) >>> jnp.allclose(jnp.array([jnp.nan, 1, 2]), ... jnp.array([jnp.nan, 1, 2]), equal_nan=True) Array(True, dtype=bool) allclose)r*rr(allr+)rrr(r)r%s rKrr s:Xz1a((( 1dD)<< = ==rLc, tjd|t|}~t|dkrt d|jt kr|n|dk}||n|}tj |d |j dks dkr t fd|j DStjttj|  t!j|j dddddd|j zt&}t fd t)||j D}|t+|tr|n |j|fz}t-d |Drt d |jd |t/ |k t fd t1||D}|S)a Return indices of nonzero elements of an array. JAX implementation of :func:`numpy.nonzero`. Because the size of the output of ``nonzero`` is data-dependent, the function is not compatible with JIT and other transformations. The JAX version adds the optional ``size`` argument which must be specified statically for ``jnp.nonzero`` to be used within JAX's transformations. Args: a: N-dimensional array. size: optional static integer specifying the number of nonzero entries to return. If there are more nonzero elements than the specified ``size``, then indices will be truncated at the end. If there are fewer nonzero elements than the specified size, then indices will be padded with ``fill_value``, which defaults to zero. fill_value: optional padding value when ``size`` is specified. Defaults to 0. Returns: Tuple of JAX Arrays of length ``a.ndim``, containing the indices of each nonzero value. See also: - :func:`jax.numpy.flatnonzero` - :func:`jax.numpy.where` Examples: One-dimensional array returns a length-1 tuple of indices: >>> x = jnp.array([0, 5, 0, 6, 0, 7]) >>> jnp.nonzero(x) (Array([1, 3, 5], dtype=int32),) Two-dimensional array returns a length-2 tuple of indices: >>> x = jnp.array([[0, 5, 0], ... [6, 0, 7]]) >>> jnp.nonzero(x) (Array([0, 1, 1], dtype=int32), Array([1, 0, 2], dtype=int32)) In either case, the resulting tuple of indices can be used directly to extract the nonzero values: >>> indices = jnp.nonzero(x) >>> x[indices] Array([5, 6, 7], dtype=int32) The output of ``nonzero`` has a dynamic shape, because the number of returned indices depends on the contents of the input array. As such, it is incompatible with JIT and other JAX transformations: >>> x = jnp.array([0, 5, 0, 6, 0, 7]) >>> jax.jit(jnp.nonzero)(x) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ConcretizationTypeError: Abstract tracer value encountered where concrete value is expected: traced array with shape int32[]. The size argument of jnp.nonzero must be statically specified to use jnp.nonzero within JAX transformations. This can be addressed by passing a static ``size`` parameter to specify the desired output shape: >>> nonzero_jit = jax.jit(jnp.nonzero, static_argnames='size') >>> nonzero_jit(x, size=3) (Array([1, 3, 5], dtype=int32),) If ``size`` does not match the true size, the result will be either truncated or padded: >>> nonzero_jit(x, size=2) # size < 3: indices are truncated (Array([1, 3], dtype=int32),) >>> nonzero_jit(x, size=5) # size > 3: indices are padded with zeros. (Array([1, 3, 5, 0, 0], dtype=int32),) You can specify a custom fill value for the padding using the ``fill_value`` argument: >>> nonzero_jit(x, size=5, fill_value=len(x)) (Array([1, 3, 5, 6, 6], dtype=int32),) rdrzZCalling nonzero on 0d arrays is not allowed. Use jnp.atleast_1d(scalar).nonzero() instead.NzlThe size argument of jnp.nonzero must be statically specified to use jnp.nonzero within JAX transformations.c3BK|]}ttVdSr`)rr^)r*dimcalculated_sizes rKr,znonzero..- s-BB,,BBBBBBrLr4rc3.K|]\}}|z|zVdSr`rj)r*strider flat_indicess rKr,znonzero..1 s1 Z Z,&$|v%- Z Z Z Z Z ZrLc3<K|]}t|dkVdS)rjN)_shape)r*rs rKr,znonzero..4 s- 7 76#;;"  7 7 7 7 7 7rLz1fill_value must be a scalar or a tuple of length ; got c3@K|]\}}t||VdSr`r)r*fvalentry fill_masks rKr,znonzero..7 s3__+$iu--______rL)r*rrSrErrPrNrrrtrrGr?r(cumsumr:r}rrrrrFr6rr7) rrrZrmaskcalculated_size_rrfill_value_tuprrrs @@@rKrdrd s(by!$$$ # #YY!^^ E F FF T!!q$#'>> x = jnp.array([[0, 5, 0], ... [6, 0, 8]]) >>> jnp.flatnonzero(x) Array([1, 3, 5], dtype=int32) This is equivalent to calling :func:`~jax.numpy.nonzero` on the flattened array, and extracting the first entry in the resulting tuple: >>> jnp.nonzero(x.ravel())[0] Array([1, 3, 5], dtype=int32) The returned indices can be used to extract nonzero entries from the flattened array: >>> indices = jnp.flatnonzero(x) >>> x.ravel()[indices] Array([5, 6, 8], dtype=int32) rYr)rdr)rrrZs rK flatnonzeror; s%T q < < j d tfdt|DStdd|djd|d )Nc8tjd|dS)Nz argument of jnp.padr@)rr)rMrs rKrz%_broadcast_to_pairs.. s"&tQ48U8U8UVVVrLz array has an inhomogeneous shape`"` entries must be the same shape: ctj|stj|s|St dd)Nrr)ris_dimr}r?rx)rrrs rK as_scalar_dimz*_broadcast_to_pairs..as_scalar_dim sH {1~~KRXa[[K h I$II%II J JJrLrc3\K|]&}|d|dfV'dSrrNrj)r*nvalrs rKr,z&_broadcast_to_pairs.. sDTTd--Q((--Q*@*@ATTTTTTrLrrrrYc3K|]}VdSr`rjr*rDv1_2s rKr,z&_broadcast_to_pairs.. #))!))))))rLrrrc3K|]}VdSr`rjr s rKr,z&_broadcast_to_pairs.. rrLrc3 K|]}fV dSr`rjr*rDrs rKr,z&_broadcast_to_pairs.. '++A!Q++++++rLrjc3 K|]}fV dSr`rjrs rKr,z&_broadcast_to_pairs.. rrLz jnp.pad: z with nd=z has unsupported shape z. Valid shapes are (z , 2), (1, 2), (2,), (1,), or ().) r}rSrrrArxr?rGrflat)rrrerrr s` ` @@@rK_broadcast_to_pairsr s JxVVVV     EE    )SVV33 I$II%II J JPQQ  KKKKKK  [RG TTTTeTTT T TT {f =t % %}}U4['A'A AD ))))uRyy))) ) )) {d =q " "MM%($;$; ;D ))))uRyy))) ) )) {d eAhA ++++r+++ + ++ {b ejm$$A ++++r+++ + ++ OOOROOOO*,OOO P PPs%- A$(AA$ axis_paddingtuple[Any, Any]c~|ddks |ddkr$d}t||dS)Nrrz'Cannot apply '{}' padding to empty axis)rr )rrrns rK_check_no_paddingr sF1o\!_q00 3C SZZ%% & &&10rL pad_width PadValue[int]constant_valuesct|}t||df}tj||jt j|}t|D]l}dg|z}||dddf||<tj |||df|}d||ddf||<tj |||df|}m|S)Nrrrrrr) rErr_convert_element_typerPris_weakly_typedrrpad)rrrrrDwidthss rK _pad_constantr$ s E{{" 2q'::/ 6u{F$:5$A$ACC/ 99::a[2 F1a!Q'F1I GE?1a40& 9 9EIaLOQ'F1I GE?1a40& 9 9EE ,rLc tt|D]}|j|dkrt||d*|j|}t ||d|\}}t ||d|\}}||zdz}g} |dkr| t j|||z ||gz } | ||gzz } |dkr| t j|d||gz } t j| |}|S)Nrrrrh dimension)rrEr?rrrrr) rrrDr left_repeatsleft_remainder right_repeatsright_remainder total_repeatspartss rK _pad_wrapr. s' e  00a {1~ ! f--- ;q>D#))A,q/4#@#@ L.%+IaLOT%B%B"M? =014M E  ~(=t!LLLMMe ]eW $$E  ?CCCDDe OEQ / / /EE ,rL reflect_typecFdvsJdvsJtt|D]s|jdkrt|*|jfd}|||dd}|||dd}t|S) N symmetricreflect)evenoddrcdrtj|dd }ntj|dd }  fd} dkr dkrdnd}tj f }|r& dkr |z kst |n/#tj$r}t ||d}~wwxYwdkrt  |z }|z|rdksJr|} ||z} n||z } dks dkrdnd} tj|| | } t| } dkrAd |z| z } dkr3rtj| dd }ntj| dd }rtj| |g }ntj|| g }dk|S) Nrrrhrc *dddrdnddd S)NzShape polymorphism is supported for jnp.pad with 'reflect' or 'symmetric' padding mode only when it is possible to determine at lowering time that the axis size (= zB) is larger than 1 and larger or equal than the padding length (= z). Error while handling rBr z padding on axis rrj) axis_sizebeforerDrsrKrzB_pad_symmetric_or_reflect..build_padding.. sb W4= W W=D W W-3"?&&  W WST  W W WrLr3r2r5rr&) rrrr rInconclusiveDimensionOperationrrr)rrr9edgeshape_poly_error_msgoffset has_poly_dimrcurr_padrstoprMr8rDrr/s `` rK build_paddingz0_pad_symmetric_or_reflect..build_padding sh 9q!!444r4a888XXXXXXX 8y((Y]]19g2FGGG  3Q9v3E3P3P//1122 2  0888--//00a78 aKKw F 2338 ,1  I%("$$v%&%+--ab$  UE4a 8 8 8 OOO 5 $hl! ]] ;%aAA666dd%aT:::d  ;/1e*:::%%/5!*:::%5 aKK6lsABB<B77B<T)r9rF)rrEr?r)rrrr/rAr8rDs `` @@rK_pad_symmetric_or_reflectrB s ) ) ) ) )  ( ( ( ( e  <@<@a {1~ ! d+++ AI22222222h M%1a > > >E M%1a ? ? ?EE ,rLct|}t|D]}|j|dkrt||d*|j|}||\}}t j|dd|}t |||}t j||dz ||} t | ||} t j||| g|}|S)Nrr;rrhr&)rErr?rrrrepeatr) rrrrDr npad_before npad_after edge_before pad_before edge_after pad_afters rK _pad_edgerK# s E{{" 99IIa {1~ ! f--- AA'lK"5!QQ777K [q999J!%1aa888Jz:A666I OZ :a H H HEE ,rL end_valuesPadValue[ArrayLike]c tt|D]6}tj|dd|}tj|dd|}t ||d||||dd|j|}tj|tj |}t ||d||||dd|j|}tj|tj |}t||}tj |||g|}8|S) NrrrhrFrr@numendpointrPrb) weak_typer&) rrErrrrrPrr rr!rr)rrrLrbrGrI ramp_before ramp_afters rK_pad_linear_ramprU7 sjDKK  NNd"5!QT:::K!%T===Jq!   & & dOA k  K4v5e<<>>>Kq!    % % dOA k  J3f4U;;===Jj$''J O[%< M M MEE ,rL stat_lengthPadValue[int] | None stat_funcczt|}t|D]}||||d}|}n|j|}||\} } | dks| dkrtdt | |} t | |} t j|d| |} t j|| d|} || |d}|| |d}tj|j tj rt|}t|}tj ||j tj|}tj ||j tj|}||\} }t!|| |}t!|||}t j|||g|}|S)NTrrz,stat_length of 0 yields no value for paddingrhr&)rErr?rrrrr}rTrPrrrr rr!rDr)rrrVrXrrD stat_before stat_after array_length length_before length_after slice_before slice_afterrErFrHrJs rK _pad_statsraX s E{{" 99 I IaIe!d;;;kjj[^l$/N!m\ !  |q00GHHH-66m|44l%eQ AFFFl$U\M4aHHHkIlTBBBk9[q4@@@j }U["*--%+&&k$$j4U[&"8"?"?AAK3EK!7!>!>@@J(lK [q999Jz:A666I OZ :a H H HEE ,rLctt|D]}|jd|||dfz|j|dzdz}t||}|jd|||dfz|j|dzdz}t||}t j|||g|}|S)Nrrr)r&)rrEr? empty_likerr)rrrD shape_beforerH shape_afterrJs rK _pad_emptyrf s e  IIa;rr?il1o%77%+a!eff:MMLE666J+bqb/Yq\!_$66QUVV9LLK5 444I OZ :a H H HEE ,rLfuncCallable[..., Any]c t|t|d}t||td}t t|D]}t |||||||}|S)Nrr)rrEr$rSrapply_along_axis)rrrgrpaddedrbs rK _pad_funcrl sq!)T%[[+FF)  71:: 6 6&DLL!!QQd dD&)D/4 P PFF -rL)rrr^)static_argnumsPadValueLike[int]PadValueLike[ArrayLike]c t|}t|}|dkr|Stjtjtjtjd}t||d}tj |} | j |dfkrtd|dfd| j dtj | dkrtd|d krt||t|S|d krt||S|d vrt||t!||S|d krt#||S|d kr"t||d}t%|||S||vr8|t||d}t'||||t!|S|dkrt)||SJd)Nr)rrmeanmedianrrz!Expected pad_width to have shape rrz#index can't contain negative valuesconstantrr1r; linear_ramprLrVemptyFzTShould not be reached since pad already handled unsupported andnot implemented modes)rSrEr(amaxaminrsrtrr}rr?rr6r$r.rBrArKrUrarf) rrrrrVrLr/r stat_funcs pad_width_arrs rK_padr| s %..% E{{"1WW Lo! ((*")R==)(9%%-RG## ^"a^^ H[^^^ _ __VMA < : ; ;; Z  7?+C+C D DD v~~ UI & && ''' $UIs4yy, O OO v~~ UI & && }$Z\BBJ E9j 9 99 z' RGGk eY ZD 5J K KK w eY ' '',+,,,rLzUnlike numpy, JAX "function" mode's argument (which is another function) should return the modified array. This is because Jax arrays are immutable. (In numpy, "function" mode's argument should modify a rank 1 array in-place.) ru&PadValueLike[int | Array | np.ndarray]str | Callable[..., Any]c tjd|t|t|d}|r(t d|Dst dt |rtt|||fi|Sgggdgdgdgdgdgdgdgdgd } t|t||z }n2#t$r%d }t| |wxYw|r#td |||dd }|dd}|dd } |dd } t|||||| | S)Nr"rc3~K|]8}tj|dotj|dV9dSrrr)r*rs rKr,zpad.. sW//  ;qt,,BQqT1B1B//////rLz%`pad_width` must be of integral type.rrLrVr/) rwr;rrurvrrsrtrr3r2z+Unimplemented padding mode '{}' for np.pad.z/unsupported keyword arguments for mode '{}': {}rr4)r*rrrErrxcallablerlrSsetKeyErrorrr rgetr|) rrrrallowed_kwargsunsupported_kwargsrnrrVrLr/s rKr"r" sue$$$!)T%[[+FF)=s//$-/////= ; < << d^^@ WU^^Y ? ? ? ??2r$%"^o !"#  .0Vs>$+?'@'@@ 000 7C cjj.. / //08 FfT#566 8 88JJ0!44/ =$//+zz,***NF33, eYo{JP\ ] ]]s %C/C5arrays(np.ndarray | Array | Sequence[ArrayLike]c\t|std|tdt|tjt fr8t||j}tt||dz||Stj dg|Rt|d}t|t|dz}g}|D]G}t||krtd|t||Ht|||S)Nz!Need at least one array to stack.z1The 'out' argument to jnp.stack is not supported.rrbrPrjrz*All input arrays must have the same shape.)rrrrFr}rr,rOrErrr*rr?r8)rrbrrPshape0 new_arraysrs rKrjrj s/ V: 8 9 99_ Q R RRU+,, ; dFK 0 0D {64!8444u M M MM*6**** 6!9  F dCKK!O 4 4DJ .. qV  EFFF At,,---- zE : : ::rLunstackctjd|t|}|jdkrt dt t ||dS)NrrzIUnstack requires arrays with rank > 0, however a scalar array was passed.)r*rrSrErrGr)rMrbs rKrr s`y!$$$ ajj!Vq[[    x4## $ $$rLArepsDimSize | Sequence[DimSize]c Rtjd| t|t|}n#t$r|f}YnwxYwtd|D}dt |t |z zt|z}dt |t |z z|z}tt|d|Ddt||D}t|ttj ||S)Nrc3jK|].}tj|rtj|n|V/dSr`)ris_constant_dimrr)r*reps rKr,ztile.." sU((+/*>s*C*CL8>#&&&((((((rLrc g|] }d|fD]}| Srrj)r*rDjs rKr2ztile..& s)#G#G#G!A#G#G1A#G#G#G#GrLcg|] }|D]}| Srjrj)r*pairrXs rKr2ztile..' s%LLLttLL!LLLLrL) r*riterrGrxrrEr?rr=rr}multiply)rrreps_tupA_shapers rKrr s:vq!!!JJJT{{HH ,,,%)GHHH,((&(((((( CMMDGG+ ,uQxx 7' S\\CMM1 2X =( #G#Gw#G#G#GHHLLs8W'='=LLL N N& r{7H==>> ? ??s6 AAc,t||}|jdks|jddkrtd|t j||jfS|jdkrtdt||jdz }|jd|dz|jd|j|dzzfz|j|dzdz}gtd|dzdt|dz|j}t j|||S)Nrnr'Need at least one array to concatenate.r/Zero-dimensional arrays cannot be concatenated.r) rSrEr?rrr=rrOr)rrbrPr? dimensionss rK_concatenate_arrayr* s 5!!!#X]]cila'' > ? ?? \ ;sSXK ( ((X]] F G GG D#(Q, / /$ )AdQhJ 39Q<#)D1H2E#E"G G#)TX[\T\T]T]J^ ^%Cq$(##CQCtax)B)BC* S% , ,,rLct|tjtfrt |St jdg|Rt|stdtd|DdSt|ddkrtdtt|dt j |nfd|Dd td kr?fd tdtDtd k?dS) Nrnrrc,g|]}t|Srj)rr*rs rKr2zconcatenate..B s111Qa111rLrrrc2g|]}t|Srnr)r*rrPs rKr2zconcatenate..I s&>>>'#U+++>>>rLrcPg|]"}tj||z#Srj)rr)r*rD arrays_outrbrXs rKr2zconcatenate..O sB999/*QqsU"3T::999rL)rFr}rr,rr*rrrrrErOrr)rrbrPrrXs ``@@rKrr9 s{U+,,9 fd% 8 8 88}.v.... V@ > ? ?? \ 11&111 G G GG &)__ F G GG D$vay// 2 2$ ]$f-JJ>>>>v>>>J ! J!999999 C OOQ77999J J! ArLconcatchtjdg|Rtj||S)Nrrh)r*rrrr)rrbs rKrrT s6x)&))))   vD  1 11rLtupct|tjtfr#t jt |}n!tjdg|Rddid|D}t|d|S)Nvstack emit_warningTc,g|]}t|Srj) atleast_2dr*rZs rKr2zvstack..c  ' ' 'aJqMM ' ' 'rLrr) rFr}rr,rvmaprr*rrrrParrss rKrrZ bj%())( 38J   $ $DD ;C;;;d;;; ' '3 ' ' 'D T / / //rLc.t|tjtfr-t jt |}|jdz }n.tj dg|Rddid|D}|dj}t||dkrdnd|S)NrhstackrTc,g|]}t|Srj) atleast_1drs rKr2zhstack..q rrLrr) rFr}rr,rrrrEr*rr)rrPr arr0_ndims rKrrg sbj%()) 38J   $ $D A II ;C;;;d;;; ' '3 ' ' 'DQ I TY!^^% H H HHrLct|tjtfr#t jt |}n!tjdg|Rddid|D}t|d|S)NdstackrTc,g|]}t|Srj atleast_3drs rKr2zdstack.. rrLrr) rFr}rr,rrrr*rrrs rKrrv rrLc$t|tjtfr,|jdkrt jd|n|}n4tjdg|Rddidtt|D}t|dS)Nc*t|jSr`)rr=rZs rKrzcolumn_stack.. sjmmorL column_stackrTcPg|]#}|jdkrt|jn|$Sr)rErr=r*rs rKr2z column_stack.. s0 T T T3AJsOO  3 T T TrLr) rFr}rr,rErrr*rmaprSr)rrs rKrr sbj%())U7:x!|| .38-- . .s 3 3 3DD A#AAADAAA T T#gsBSBS T T TD T1  rLchoicescp|tdtjd|g|Rtt |t st dt|}|dkrJtj t|d}tj |dk||kzrt dnG|dkrt||z}n.|d krt|d|d z }nt d |d t|g|R^}}t||ft!|jd zS)Nz2The 'out' argument to jnp.choose is not supported.choosez`a` array must be integer typedrzqThe error occurred because jnp.choose was jit-compiled with mode='raise'. Use mode='wrap' or mode='clip' instead.rzinvalid entry in choice arrayrrrzmode=z3 not understood. Must be 'raise', 'wrap', or 'clip'T)sparse)rr*rrTr[rrrrrrSr(r6rrkrrr?)rrrrr rs rKrr sU _ R S SSx-W---- F1IIw ' '8 6 7 77 'll! W__'DEEC~sQw3!8,--8 6 7 778 v~~ !**q.CC v~~ q!QU  CC XTXXX Y YY"31111-# w4!@!@!@@ AArLct|}||krtj|d||z znt|S)Nr)rEr broadcastrS)rMrrZs rK _atleast_ndr s: 1gg!-.UUq$!a%. ) ) ) BrLxstuple[Array, int]cvt|tr"td|t|trt |dkrtdt d|D\}tfdddDrtdtdtd|Dtfd |D}t|d ddzfSt|dfS) Nz-jax.numpy.block does not allow tuples, got {}rz3jax.numpy.block does not allow empty list argumentsc,g|]}t|Srj_blockr*rMs rKr2z_block.. s3331VAYY333rLc30K|]}|dkVdSrrj)r*rdepthss rKr,z_block.. s+ . .a1q > . . . . . .rLrz)Mismatched list depths in jax.numpy.blockc34K|]}t|VdSr`rrs rKr,z_block.. s(66!d1gg666666rLc38K|]}t|VdSr`)r)r*rMranks rKr,z_block.. s-88A;q$''888888rLrh) rFrGrr rHrr5r6rrrS)rxs_tuprrs @@rKrr sEE  DfRjj " """d  2ww!|| L M MM3333344NFF . . . .6!"": . . ...D B C CC vay#66v66666 7 7D 8888888 8 8F vVAYJ / / /Q >> 2;;>rLc*t|\}}|Sr`r)rrrs rKblockr s &>>&#q *rLcdSr`rjrjrLrKrr #rLcdSr`rjrZs rKrr rrLaryscdSr`rjrMrrs rKrr rrL)rrWctjdg|Rddit|dkrt|dddSd|DS) NrrTrrFrndminc2g|]}t|ddS)Frrrrs rKr2zatleast_1d.. ' < < <E#E + + + < < d>>>>>>YY!^^ auA . . .. < . rrLrrs rKrr rrLcdSr`rjrjrLrKrr rrLcdSr`rjrZs rKrr rrLcdSr`rjrs rKrr rrLcbtjdg|Rddit|dkr|t|d}|jdkrt j|d}nC|jdkrt j|d}n!|jd krt j|d }|Sd |DS) NrrTrr)rrrr)rrrrc,g|]}t|Srjrrs rKr2zatleast_3d.. s , , ,JsOO , , ,rL)r*rrrSrErr)rrs rKrr s|>d>>>>>>YY!^^ $q'  C x1}} OCI 6 6 6cc Q OCF 3 3 3cc Q OCD 1 1 1c J , ,t , , ,,rLcH t|}dS#t$rYdSwxYw)NTF) memoryviewrx)rrs rK_supports_buffer_protocolr s= c??D 4  55s  !!a  This function will create arrays on JAX's default device. For control of the device placement of data, see :func:`jax.device_put`. More information is available in the JAX FAQ at :ref:`faq-data-placement` (full FAQ at https://jax.readthedocs.io/en/latest/faq.html). jax-numpy-array-nonez| device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. )rW extra_paramsrdevicer| str | Nonerrxc.Device | Sharding | Nonec  ||dkrtdtjdduotj|}t |}|sHt |t jr. |jkr!||j kr|tj |St |ttttfrtj|}nt |t"st%|dr|}n}t%|drm|j} t+jd} t.d} n&t.| dd} t2j| | | }t9d |}t;|d } t=d | DrNt?j drtCdtEj#dtHdt;|} T | rtj%| dn tj&n0#tB$r#d| D} tj%| dYnwxYw|stj'dtQd| Drt j)|} nt |t"r|j*J|rtW|n|} nt |tXtZfr5|rt]fd|D} nt j/g} nhta|r:tc|}|rt j/|nt j)|} ntCdte|tgj4| ||}|t|kr2tkj6|to|t|z }|S)NrzOnly implemented for order='K'rr__cuda_array_interface__cudadatar)cai gpu_backend device_idcNt|dr|n|Sr)rr)leafs rKrzarray..S s.t_55"@!3!3!5!5!5;?rLc |duSr`rjrZs rKrzarray..U s drL)is_leafc3K|]}|duV dSr`rjr*r s rKr,zarray..V s&))$))))))rLrz'None is not a valid value for jnp.arrayznNone encountered in jnp.array(); this is currently treated as NaN. In the future this will result in an error.rrc,g|]}t|Srj) _convert_to_array_if_dtype_failsrs rKr2zarray..g s!JJJ4066JJJrLTallow_extended_dtypec3BK|]}t|t VdSr`)rFr,rs rKr,zarray..o s/88Ze $ $ $888888rLrnc2g|]}t|Srr)r*eltrPs rKr2zarray..z s&???73e,,,???rLz!Unexpected input type for array: )rRsharding)8rrcheck_user_dtype_supportedr!canonicalize_device_to_shardingrFr}rrPrEr device_putrNr^floatrcoerce_to_arrayr,rrrr get_backendcuda_plugin_extensionget_device_ordinalxc_xlacuda_array_interface_to_bufferrrr6ris_acceleratedrxrr FutureWarning_lattice_result_typerrrrSavalr#rHrGrjrrrrQrr rrr)r|rPrrrrrRrrrbackendr leavesr out_arrays ` rKrr sT 5C<< > ? ?? #E7333 tm> 6v > >) ,V 4 4( ":fbj11" }--EV[4H4H n >& ! !!sE7344=vu--AA fe $ $=v'' =##%%ff 3 4 4=  +c&v..g  & )<>> x = jnp.array([0, 1, 2, 3]) >>> x Array([0, 1, 2, 3], dtype=int32) >>> x.astype('float32') Array([0.0, 1.0, 2.0, 3.0], dtype=float32) >>> y = jnp.array([0.0, 0.5, 1.0]) >>> y.astype(int) # truncates fractional values Array([0, 0, 1], dtype=int32) rN)rz real floatingr0zCasting from complex to real dtypes will soon raise a ValueError. Please first use jnp.real or jnp.imag to take the real/imaginary component of your input.rrrignorer)r*rrSrrrrrTrPrUrrrr}rNrrcatch_warnings simplefilterComplexWarningrr _normalize_to_shardingr#)rMrPrrrKrs rKrr sLx### !**% ]  %f - -E#E8444 _-- . ~e:;; .* #  %D  5!,,,e  == (N333  / U3F;;===F===============!% 0V   &0s ?D++D/2D/c|durot|tsZtjdkrCt |r4t dt |dtjdtj|d|tj |d}t||t||| S) NFcpuz+jnp.asarray: cannot convert object of type z to JAX Array on backend=z@ with copy=False. Consider using copy=None or copy=True instead.rSTr)rPrrr) rFr,rdefault_backendrrrQrrrrrN)rrPrrrs rKrSrS s emmJq%00m   5 ( ( #A & & ) G477GG##8#8GGG H HH #E9555   %e$ G G GE qDJJeF K K KKrLcPtjd|t|d|S)NrT)rr)r*rrrs rKrr s*vq!!! qt5 ) ) ))rLArrayLike | DuckTypedArrayc t|drt|dstjd|tj|d|t |}t j|d||t|S)aCreate an array full of zeros with the same shape and dtype as an array. JAX implementation of :func:`numpy.zeros_like`. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.zeros` - :func:`jax.numpy.empty_like` - :func:`jax.numpy.ones_like` - :func:`jax.numpy.full_like` Examples: >>> x = jnp.arange(4) >>> jnp.zeros_like(x) Array([0, 0, 0, 0], dtype=int32) >>> jnp.zeros_like(x, dtype=bool) Array([False, False, False, False], dtype=bool) >>> jnp.zeros_like(x, shape=(2, 3)) Array([[0, 0, 0], [0, 0, 0]], dtype=int32) rPr?rNrr3 rr*rrrrJr full_liker7rrPr?rs rKrr sD !W  *'!W"5"5*q)))#E<888  u % %E q!UE4J64R4R S S SSrLc t|drt|dstjd|tj|d|t |}t j|d||t|S)aCreate an array of ones with the same shape and dtype as an array. JAX implementation of :func:`numpy.ones_like`. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.ones_like` - :func:`jax.numpy.full_like` Examples: >>> x = jnp.arange(4) >>> jnp.ones_like(x) Array([1, 1, 1, 1], dtype=int32) >>> jnp.ones_like(x, dtype=bool) Array([ True, True, True, True], dtype=bool) >>> jnp.ones_like(x, shape=(2, 3)) Array([[1, 1, 1], [1, 1, 1]], dtype=int32) rPr?rNrr3r>r@s rKrr#sD !W  )'!W"5"5)a(((#E;777  u % %E q!UE4J64R4R S S SSrL prototypect|drt|dstjd|tj|dt ||||S)aNCreate an empty array with the same shape and dtype as an array. JAX implementation of :func:`numpy.empty_like`. Because XLA cannot create an un-initialized array, :func:`jax.numpy.empty` will always return an array full of zeros. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.ones_like` - :func:`jax.numpy.full_like` Examples: >>> x = jnp.arange(4) >>> jnp.empty_like(x) Array([0, 0, 0, 0], dtype=int32) >>> jnp.empty_like(x, dtype=bool) Array([False, False, False, False], dtype=bool) >>> jnp.empty_like(x, shape=(2, 3)) Array([[0, 0, 0], [0, 0, 0]], dtype=int32) rPr?rc)rPr?r)rr*rrrr)rBrPr?rs rKrcrcMseH )W % %2')W*E*E2y111#E<888 IU% G G GGrLcXt|tjrt|S|Sr`r-rs rKr7r7ws) ""  ' '' MrLcHtj|dtjd|t |dkr4t |}t j|||t|Stj tt||||S)aTCreate an array full of a specified value. JAX implementation of :func:`numpy.full`. Args: shape: int or sequence of ints specifying the shape of the created array. fill_value: scalar or array with which to fill the created array. dtype: optional dtype for the created array; defaults to the dtype of the fill value. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.full_like` - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros` - :func:`jax.numpy.ones` Examples: >>> jnp.full(4, 2, dtype=float) Array([2., 2., 2., 2.], dtype=float32) >>> jnp.full((2, 3), 0, dtype=bool) Array([[False, False, False], [False, False, False]], dtype=bool) `fill_value` may also be an array that is broadcast to the specified shape: >>> jnp.full((2, 3), fill_value=jnp.arange(3)) Array([[0, 1, 2], [0, 1, 2]], dtype=int32) rrr3rn) rrr*rrErJrrr7rrrrS)r?rZrPrs rKrr~sJ #E6222vz*** * u % %E 8E:u7Mf7U7U V V VV >WZu555u==v G GGrLc t|dr't|drtjdd|ntjd||tj|d|t |}t |dkr&tj||||t|S|tj |n|}|t|n|}tjtt!||||S)aCreate an array full of a specified value with the same shape and dtype as an array. JAX implementation of :func:`numpy.full_like`. Args: a: Array-like object with ``shape`` and ``dtype`` attributes. fill_value: scalar or array with which to fill the created array. shape: optionally override the shape of the created array. dtype: optionally override the dtype of the created array. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.full` - :func:`jax.numpy.empty_like` - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.ones_like` Examples: >>> x = jnp.arange(4.0) >>> jnp.full_like(x, 2) Array([2., 2., 2., 2.], dtype=float32) >>> jnp.full_like(x, 0, shape=(2, 3)) Array([[0., 0., 0.], [0., 0., 0.]], dtype=float32) `fill_value` may also be an array that is broadcast to the specified shape: >>> x = jnp.arange(6).reshape(2, 3) >>> jnp.full_like(x, fill_value=jnp.array([[1], [2]])) Array([[1, 1, 1], [2, 2, 2]], dtype=int32) rPr?r?rNr3rn)rr*rrrrJrErr?r7r}r?rrrrrS)rrZrPr?rs rKr?r?sP Q5WQ005a4444a444#E;777  u % %E * =Ju?UV\?]?] ^ ^ ^^ =BHQKKKeE#mKNNNE >WZu555u==v G GGrLcDt|tjrtdt d||x}rt|t j|dt|}tj |dt|t|S)a Create an array full of zeros. JAX implementation of :func:`numpy.zeros`. Args: shape: int or sequence of ints specifying the shape of the created array. dtype: optional dtype for the created array; defaults to floating point. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.zeros_like` - :func:`jax.numpy.empty` - :func:`jax.numpy.ones` - :func:`jax.numpy.full` Examples: >>> jnp.zeros(4) Array([0., 0., 0., 0.], dtype=float32) >>> jnp.zeros((2, 3), dtype=bool) Array([[False, False, False], [False, False, False]], dtype=bool) :expected sequence object with len >= 0 or a single integerrrr3) rFtypes GeneratorTyperx_check_forgot_shape_tuplerrrJrrrr7r?rPrrZs rKrrs8u*++R P Q QQ $WeU ; ;;aPIaLL>P#E7333 U # #% %Ju--8Nv8V8V W W WWrLcDt|tjrtdt d||x}rt|t |}t j|dtj |dt|t|S)aCreate an array full of ones. JAX implementation of :func:`numpy.ones`. Args: shape: int or sequence of ints specifying the shape of the created array. dtype: optional dtype for the created array; defaults to floating point. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.ones_like` - :func:`jax.numpy.empty` - :func:`jax.numpy.zeros` - :func:`jax.numpy.full` Examples: >>> jnp.ones(4) Array([1., 1., 1., 1.], dtype=float32) >>> jnp.ones((2, 3), dtype=bool) Array([[ True, True, True], [ True, True, True]], dtype=bool) rHonesrr3) rFrIrJrxrKrJrrrrrr7rLs rKrNrN s8u*++R P Q QQ $VUE : ::aO9Q<<=O U # #%#E6222 %Ju--8Nv8V8V W W WWrLctd||x}rt|tj|dt |||S)aCreate an empty array. JAX implementation of :func:`numpy.empty`. Because XLA cannot create an un-initialized array, :func:`jax.numpy.empty` will always return an array full of zeros. Args: shape: int or sequence of ints specifying the shape of the created array. dtype: optional dtype for the created array; defaults to floating point. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of the specified shape and dtype, on the specified device if specified. See also: - :func:`jax.numpy.empty_like` - :func:`jax.numpy.zeros` - :func:`jax.numpy.ones` - :func:`jax.numpy.full` Examples: >>> jnp.empty(4) Array([0., 0., 0., 0.], dtype=float32) >>> jnp.empty((2, 3), dtype=bool) Array([[False, False, False], [False, False, False]], dtype=bool) rwr)rKrxrrrrLs rKrwrw.sN< %WeU ; ;;aPIaLL>P#E7333 ueF + + ++rLct|tr-t|trd|d|d|d|d|d|d|dSdSdS)NzCannot interpret 'z9' as a data type. Did you accidentally write `jax.numpy.(, z)` when you meant `jax.numpy.z((z5))`, i.e. with a single tuple argument for the shape?rFr^)rr?rPs rKrKrKPss; 5# 6 6; : : : : :!& : :*/ : :*. : :27 : :;@ : : :;;;;;rLa1a2c t|t|}}t|t|krtdSt||k}|rLtj|tjtj|tj|}tj|S)a@Check if two arrays are element-wise equal. JAX implementation of :func:`numpy.array_equal`. Args: a1: first input array to compare. a2: second input array to compare. equal_nan: Boolean. If ``True``, NaNs in ``a1`` will be considered equal to NaNs in ``a2``. Default is ``False``. Returns: Boolean scalar array indicating whether the input arrays are element-wise equal. See Also: - :func:`jax.numpy.allclose` - :func:`jax.numpy.array_equiv` Examples: >>> jnp.array_equal(jnp.array([1, 2, 3]), jnp.array([1, 2, 3])) Array(True, dtype=bool) >>> jnp.array_equal(jnp.array([1, 2, 3]), jnp.array([1, 2])) Array(False, dtype=bool) >>> jnp.array_equal(jnp.array([1, 2, 3]), jnp.array([1, 2, 4])) Array(False, dtype=bool) >>> jnp.array_equal(jnp.array([1, 2, float('nan')]), ... jnp.array([1, 2, float('nan')])) Array(False, dtype=bool) >>> jnp.array_equal(jnp.array([1, 2, float('nan')]), ... jnp.array([1, 2, float('nan')]), equal_nan=True) Array(True, dtype=bool) F) rSr?rr)r3r4rr(r)rTrUr%r|s rK array_equalrWYs@ 2;; b" 2YY%)) <<rRx"W  2v1&,r2B2BFLQSDTDTUU V VB   rLct|t|}} tj||}n#t$rt dcYSwxYwt j|S)a;Check if two arrays are element-wise equal. JAX implementation of :func:`numpy.array_equiv`. This function will return ``False`` if the input arrays cannot be broadcasted to the same shape. Args: a1: first input array to compare. a2: second input array to compare. Returns: Boolean scalar array indicating whether the input arrays are element-wise equal after broadcasting. See Also: - :func:`jax.numpy.allclose` - :func:`jax.numpy.array_equal` Examples: >>> jnp.array_equiv(jnp.array([1, 2, 3]), jnp.array([1, 2, 3])) Array(True, dtype=bool) >>> jnp.array_equiv(jnp.array([1, 2, 3]), jnp.array([1, 2, 4])) Array(False, dtype=bool) >>> jnp.array_equiv(jnp.array([[1, 2, 3], [1, 2, 3]]), ... jnp.array([1, 2, 3])) Array(True, dtype=bool) F)rSr)equalrrr(r)rTrUr|s rK array_equivrZsp: 2;; b" b"  BB  <<   s6AAbuffer bytes | Anycountr=cLttj||||S)Nr[rPr]r=)rSr} frombufferr_s rKr`r`s% fEvVVV W WWrLc td)a/Unimplemented JAX wrapper for jnp.fromfile. This function is left deliberately unimplemented because it may be non-pure and thus unsafe for use with JIT and other JAX transformations. Consider using ``jnp.asarray(np.fromfile(...))`` instead, although care should be taken if ``np.fromfile`` is used within jax transformations because of its potential side-effect of consuming the file object; for more information see `Common Gotchas: Pure Functions `_. ajnp.fromfile() is not implemented because it may be non-pure and thus unsafe for use with JIT and other JAX transformations. Consider using jnp.asarray(np.fromfile(...)) instead, although care should be taken if np.fromfile is used within a jax transformations because of its potential side-effect of consuming the file object; for more information see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#pure-functionsrrrs rKfromfilerd _ ` ``rLc td)a3Unimplemented JAX wrapper for jnp.fromiter. This function is left deliberately unimplemented because it may be non-pure and thus unsafe for use with JIT and other JAX transformations. Consider using ``jnp.asarray(np.fromiter(...))`` instead, although care should be taken if ``np.fromiter`` is used within jax transformations because of its potential side-effect of consuming the iterable object; for more information see `Common Gotchas: Pure Functions `_. ajnp.fromiter() is not implemented because it may be non-pure and thus unsafe for use with JIT and other JAX transformations. Consider using jnp.asarray(np.fromiter(...)) instead, although care should be taken if np.fromiter is used within a jax transformations because of its potential side-effect of consuming the iterable object; for more information see https://jax.readthedocs.io/en/latest/notebooks/Common_Gotchas_in_JAX.html#pure-functionsrbrcs rKfromiterrgrerL from_dlpacka_ .. note:: While JAX arrays are always immutable, dlpack buffers cannot be marked as immutable, and it is possible for processes external to JAX to mutate them in-place. If a jax Array is constructed from a dlpack buffer and the buffer is later modified in-place, it may lead to undefined behavior when using the associated JAX array. rrc*ddlm}||||S)Nr)rhri) jax.dlpackrh)rMrrrhs rKrhrhs-%$$$$$ QvD 1 1 11rLrnfunctionCallable[..., Array]c @tj|d}tt|D]Vfdtt|D}t j|t |ddd}W|fd|Di|S)Nz$shape argument of jnp.fromfunction()rc$g|] }|krdnd Srrj)r*rrDs rKr2z fromfunction..s%@@@AFFqq@@@rLrin_axesc3:K|]}t|VdS)rnN)r)r*rrPs rKr,zfromfunction..s0::qF1E***::::::rL)rrJrrrrrG)rlr?rPrrqrDs ` @rK fromfunctionrss  !%1W X X X% U  @@a@@@@eCJJ.?.?@@@Gx%" *>*>???HH ::::E::: Ef E EErLstringsepcLttj||||S)NrtrPr]ru)rSr} fromstringrws rKrxrxs# fECPPP Q QQrLr r/MDimSize | Noneint | ArrayLikec\t||||}|tj||S|S)aCreate a square or rectangular identity matrix JAX implementation of :func:`numpy.eye`. Args: N: integer specifying the first dimension of the array. M: optional integer specifying the second dimension of the array; defaults to the same value as ``N``. k: optional integer specifying the offset of the diagonal. Use positive values for upper diagonals, and negative values for lower diagonals. Default is zero. dtype: optional dtype; defaults to floating point. device: optional :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Identity array of shape ``(N, M)``, or ``(N, N)`` if ``M`` is not specified. See also: :func:`jax.numpy.identity`: Simpler API for generating square identity matrices. Examples: A simple 3x3 identity matrix: >>> jnp.eye(3) Array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]], dtype=float32) Integer identity matrices with offset diagonals: >>> jnp.eye(3, k=1, dtype=int) Array([[0, 1, 0], [0, 0, 1], [0, 0, 0]], dtype=int32) >>> jnp.eye(3, k=-1, dtype=int) Array([[0, 0, 0], [1, 0, 0], [0, 1, 0]], dtype=int32) Non-square identity matrix: >>> jnp.eye(3, 5, k=1) Array([[0., 1., 0., 0., 0.], [0., 0., 1., 0., 0.], [0., 0., 0., 1., 0.]], dtype=float32) )ryrXrPNr)_eyerr)r ryrXrProutputs rKeyers;j Q!5 ) ) )&  >& 0 0 00 -rLctj|dt|trt j|t j}tj d|t|}|j dkr$tj |j t jstd|t!j|d}||nt!j|d}|dks|dkrtd|d|t%j|j ||fd}t%j|j ||fd }||z|k|S) Nrrjz k must be a scalar integer; got z'N' argument of jnp.eye()z'M' argument of jnp.eye()rz)negative dimensions are not allowed, got rr)rrrFr^r_clip_int_to_valid_ranger}int32r*rrSr?rTrPrrrcanonicalize_dimrbroadcasted_iotar) r ryrXrPr=N_intM_intrDrs rKr}r}+sC #E51113;-a::Aua   1::& ,"  !26<!L!L  ;;; < <<  #> ? ?%9%%$"7;V"W"W% QYY%!)) LLLLL M MM 6<%;;! 6<%;;! f*/ ! !% ( ((rLcNtj|dt||S)avCreate a square identity matrix JAX implementation of :func:`numpy.identity`. Args: n: integer specifying the size of each array dimension. dtype: optional dtype; defaults to floating point. Returns: Identity array of shape ``(n, n)``. See also: :func:`jax.numpy.eye`: non-square and/or offset identity matrices. Examples: A simple 3x3 identity matrix: >>> jnp.identity(3) Array([[1., 0., 0.], [0., 1., 0.], [0., 0., 1.]], dtype=float32) A 2x2 integer identity matrix: >>> jnp.identity(2, dtype=int) Array([[1, 0], [0, 1]], dtype=int32) identityrn)rrr)rrPs rKrr>s*: #E:666 Qe   rLrArrayLike | DimSizer@ArrayLike | DimSize | Nonestepc\t||||}|tj||S|S)a Create an array of evenly-spaced values. JAX implementation of :func:`numpy.arange`, implemented in terms of :func:`jax.lax.iota`. Similar to Python's :func:`range` function, this can be called with a few different positional signatures: - ``jnp.arange(stop)``: generate values from 0 to ``stop``, stepping by 1. - ``jnp.arange(start, stop)``: generate values from ``start`` to ``stop``, stepping by 1. - ``jnp.arange(start, stop, step)``: generate values from ``start`` to ``stop``, stepping by ``step``. Like with Python's :func:`range` function, the starting value is inclusive, and the stop value is exclusive. Args: start: start of the interval, inclusive. stop: optional end of the interval, exclusive. If not specified, then ``(start, stop) = (0, start)`` step: optional step size for the interval. Default = 1. dtype: optional dtype for the returned array; if not specified it will be determined via type promotion of `start`, `stop`, and `step`. device: (optional) :class:`~jax.Device` or :class:`~jax.sharding.Sharding` to which the created array will be committed. Returns: Array of evenly-spaced values from ``start`` to ``stop``, separated by ``step``. Note: Using ``arange`` with a floating-point ``step`` argument can lead to unexpected results due to accumulation of floating-point errors, especially with lower-precision data types like ``float8_*`` and ``bfloat16``. To avoid precision errors, consider generating a range of integers, and scaling it to the desired range. For example, instead of this:: jnp.arange(-1, 1, 0.01, dtype='bfloat16') it can be more accurate to generate a sequence of integers, and scale them:: (jnp.arange(-100, 100) * 0.01).astype('bfloat16') Examples: Single-argument version specifies only the ``stop`` value: >>> jnp.arange(4) Array([0, 1, 2, 3], dtype=int32) Passing a floating-point ``stop`` value leads to a floating-point result: >>> jnp.arange(4.0) Array([0., 1., 2., 3.], dtype=float32) Two-argument version specifies ``start`` and ``stop``, with ``step=1``: >>> jnp.arange(1, 6) Array([1, 2, 3, 4, 5], dtype=int32) Three-argument version specifies ``start``, ``stop``, and ``step``: >>> jnp.arange(0, 2, 0.5) Array([0. , 0.5, 1. , 1.5], dtype=float32) See Also: - :func:`jax.numpy.linspace`: generate a fixed number of evenly-spaced values. - :func:`jax.lax.iota`: directly generate integer sequences in XLA. r@rrPNr)_arangerr)rr@rrPrr~s rKrr_s;R 5t$e < < <&  >& 0 0 00 -rLcPtj|dtjjsFt jd|||tjd|d}ntjd|d}t j dd||tjd|d}tjd|d}||dnd}||fd|fd|ffD]4\}}|-tj |dkrtd |d |5td |||fDrA| ||}d}d }n||d }t||||ptjtjS|t#|gd ||fDR}t%|}||t'|}tj|tjsttj|tjsUt/|tjr t2jn tj}||t8}t;j||S|G|dkrA|?t;j|tj|t8St?tj ||||S)Nrz*It arose in the jnp.arange argument 'stop'z+It arose in the jnp.arange argument 'start'z*It arose in the jnp.arange argument 'step'r@rrrz1jax.numpy.arange: arguments must be scalars; got =c3>K|]}tj|VdSr`)rrr*rs rKr,z_arange..s->>Q a >>>>>>rLrc3K|]}||V dSr`rjrs rKr,z_arange..s" J JqAMMMMM J JrLr)!rrrdynamic_shapesvaluer*rrrcheck_arraylike_or_noner}rErr6_arange_dynamicrrrrr[rTrrrFTracerr)rrr^riotarr) rr@rrP start_namerr start_dtypeceil_s rKrrs#E8444   $a5))) | $T52^__ee$T52_``extT::: d,X Y Y$ d,X Y Y$$,vvG*'&$&$HYYidC 273<<1,, W4WWRUWW X XX>>5$*=>>>>>\ | de dd dl d 5$e.Zv7PQSQY7Z7Z [ [[ ]  K J JT4L J J J K K KE U  % \dl--K  k2: 6 6'  k6? ; ;''t{;;HfkkeeEll!!#&&e 8E5 ! !! | t'7 XeRWT]]11#66 7 77 5t$eDDD E EErLctd|||fDrtd|d|d| |dkrtd|dk}n5#tj$r#}tjd|dd |zd}~wwxYw|r|n| }|r||z n||z }tjd||zd z |z}t || t || t j||zzS) Nc3@K|]}tj| VdSr`rrs rKr,z"_arange_dynamic..s-99T[^^ 999999rLz{In arange with non-constant arguments all of start, stop, and step must be either dimension expressions or integers: start=z, stop=z, step=rzarange has step == 0z0In arange with non-constant arguments the step () must 5be resolved statically if it is > 0 or < 0. Details: rrn)r6rrr:max_dimrrr) rr@rrP step_gt_0rgapdistancers rKrrsp 99eT4%899999%  $CH $ $ $ $! $ $ % %% F qyy - . ..II ,FFF  -H4HHHDDD E F FFF%v#( tj|tj| |fgt3||j}n|dkr.t|rt6n||z |} t)| | }nttj t|t|}||dtt6|} t)t#g||}t9|t:r.t9|jt:stj|}t?|}tAj!|||}|r|| fn|S) zAImplementation of linspace differentiable in start and stop args.rrzNumber of samples, z, must be non-negative.Nrnrr3)"rrrr*rrrrrSrHrrxr?rrr"rrrIrPr=rrrrrOrErrTrrrrr )rr@rPrQrrPrbrcomputation_dtype bounds_shapebroadcast_startbroadcast_stoprrQ iota_shape real_dtyperr empty_shaperrs rKrrse #E:6661WW G3GGG H HHz5$/// ]  #Kt$<$< = =E U  %-e44 %0 1 1 1% . / / /$c*5<<tEEFF,  55/l33.)-\  T !A % %t$dA&q3#1WW+D5L:KLLuUX`qOrOrOrrEL)))JJt())/J 38J,,j 9 9E#z nl++d2 3C@ OS#/.4'"J"JK.tSX>> @ @c axx 85CC=N O O OE /< 0 0CCs+E%LL%++FFGGKtQ C0 1 1 1E %%(((+ 6 6Cw 39g(F(F )C..C ,V 4 4(  -c58 L L L&# /&%/rL$@basec tjtj|d}tjtj|d}t |||||||S)Nz'num' argument of jnp.logspacez'axis' argument of jnp.logspace)rrrr _logspace)rr@rPrQrrPrbs rKlogspacerMsL x~s4TUU# 6W X X$ 5$XtUD A AArL)rPrQrPrbc tj|d|"tjt||}t |}tj|}t jd||t||}t||}t||||dd|}tj tj |||S)zAImplementation of logspace differentiable in start and stop args.rNrnF)rQrrPrb) rrrrrr*rrSrrrr)power) rr@rPrQrrPrbrlins rKrrUs  #E:666 ]  #Kt$<$< = =E U  %-e44z5$/// %0 1 1 1% . / / /$c"ED J J J# !&,tS"9"95 A AArLctjtj|d}tjtj|d}t ||||||S)Nz'num' argument of jnp.geomspacez 'axis' argument of jnp.geomspace)rrrr _geomspacerOs rK geomspacergsJ x~s4UVV# 6X Y Y$ E4ht < <.s ! ! !'!** ! ! !rLz*jax.numpy.meshgrid only supports copy=True)rHijz1Valid values for indexing are 'xy' and 'ij', got c3,K|]}|jdkVdSr.rrs rKr,zmeshgrid..s(##1######rLz7Arguments to jax.numpy.meshgrid must be 1D, got shapes cg|] }|j Srjr)rs rKr2zmeshgrid..s///Q///rLrHrrrc2g|]}rdn |jdSrrr))r*rrs rKr2zmeshgrid..s( 5 5 51 &11AGAJ 5 5 5rLcXr&gd||jd|dzdnS)Nrrr))rDrr?rs rKrzmeshgrid..s<fWBE"1"IBqwqzBE!a%&&MBBRWrLc Xg|]&\}}tj||||f'Srj)rbroadcast_in_dim)r*rDr_a_shapes rKr2zmeshgrid..s8 W W WeaC HHQNNQD 9 9 W W WrL)r*rrr6rr)rrrrrr~rr?s ` @@rKrrswz'B'''' ! !b ! ! !$ C A B BB \!! SSS T TT##d#####3 2//$///22 3 33 #d))q..AwQDGT!W 5 5 5 5 5 5 5% W W W W W( W W W WyQU W W W& #d))q..!!9fQiF1Ivay -rLcFtjd|\}t|jtjst dt|tj |}tj tj |tj |S)Ni0z(Unsupported input type to jax.numpy.i0: ) r*r-rTrPr}rrr[rr0r1exp bessel_i0e)rMrKs rKrrs}  $T1 - -&% EK - -M Kq KK L LL '%..% !6!6 7 77rLctjtj||\}}|t |ddkd|fS)Nrr)rjvprfunr)primalstangents primal_out tangent_outs rK_i0_jvprs;GBFGX>>*k U71:?C== ==rLc tjdg|Rt|}g}t|D]\}}t |}t|jdkr)d}t ||jt|tkrtddg|z}|jd||<|j dkrF| tj|tjdtj| tj|||ft'|S)avReturn a multi-dimensional grid (open mesh) from N one-dimensional sequences. JAX implementation of :func:`numpy.ix_`. Args: *args: N one-dimensional arrays Returns: Tuple of Jax arrays forming an open mesh, each with N dimensions. See Also: - :obj:`jax.numpy.ogrid` - :obj:`jax.numpy.mgrid` - :func:`jax.numpy.meshgrid` Examples: >>> rows = jnp.array([0, 2]) >>> cols = jnp.array([1, 3]) >>> open_mesh = jnp.ix_(rows, cols) >>> open_mesh (Array([[0], [2]], dtype=int32), Array([[1, 3]], dtype=int32)) >>> [grid.shape for grid in open_mesh] [(2, 1), (1, 2)] >>> x = jnp.array([[10, 20, 30, 40], ... [50, 60, 70, 80], ... [90, 100, 110, 120], ... [130, 140, 150, 160]]) >>> x[open_mesh] Array([[ 20, 40], [100, 120]], dtype=int32) ixrz>Arguments to jax.numpy.ix_ must be 1-dimensional, got shape {}z6Boolean arguments to jax.numpy.ix_ are not implementedrrj)r*rrrrSr?rr r[rrrr8rrr}rintprrG)rrr~rDrrnr?s rKr>r>s5Bt#d#### $ii! &oo::da A 17||q Lc szz!'** + ++ ayyE @ B BB C!GEwqzE!Hv{{ mmCHUBHR$9$9::;;;; mmC(EA4889999 vrLrcdSr`rjrrPrs rKrrs69crLcdSr`rjrs rKrrs.sH  X^Q0TUUrLrrrrn) rrrrrGrrrrr8rrjr) rrPrr r~rrDrrps rKrrs$ #E9555  26,T22%* *oo! &!*%%66fa (5#  C - q&C6/D!a%!), ,a MM#&sAt445555  ==# ?vq   r)?)?)??rL)total_repeat_lengthrrc  tjd|tj|ptjd||t |}d}nt |}tjtj|d}t|tsJtj |r|td|d|d|tjd|d}tj|dkrt|dkrt|}t!|t#|}|d z t%|}| tj|rtj|n|t+j|| fd t/t#|D}t%|}||xx|zcc<t1||Stj|}t|dkr)tj|t||g}tj|}nFt |}t|dkr$t3|t||g}t|dkr3t|d krt7|g|Std |dkrMt%t|}d||<t1t9gt;| |St||dkrt |St=|d jd d}tCj"|}tG|gtH } | j|%d } tCj"| d z } tM|| |S)aD Construct an array from repeated elements. JAX implementation of :func:`numpy.repeat`. Args: a: N-dimensional array repeats: 1D integer array specifying the number of repeats. Must match the length of the repeated axis. axis: integer specifying the axis of ``a`` along which to construct the repeated array. If None (default) then ``a`` is first flattened. total_repeat_length: this must be specified statically for ``jnp.repeat`` to be compatible with :func:`~jax.jit` and other JAX transformations. If ``sum(repeats)`` is larger than the specified ``total_repeat_length``, the remaining values will be discarded. If ``sum(repeats)`` is smaller than ``total_repeat_length``, the final value will be repeated. Returns: an array constructed from repeated values of ``a``. See Also: - :func:`jax.numpy.tile`: repeat a full array rather than individual values. Examples: Repeat each value twice along the last axis: >>> a = jnp.array([[1, 2], ... [3, 4]]) >>> jnp.repeat(a, 2, axis=-1) Array([[1, 1, 2, 2], [3, 3, 4, 4]], dtype=int32) If ``axis`` is not specified, the input array will be flattened: >>> jnp.repeat(a, 2) Array([1, 1, 2, 2, 3, 3, 4, 4], dtype=int32) Pass an array to ``repeats`` to repeat each value a different number of times: >>> repeats = jnp.array([2, 3]) >>> jnp.repeat(a, repeats, axis=1) Array([[1, 1, 2, 2, 2], [3, 3, 4, 4, 4]], dtype=int32) In order to use ``repeat`` within ``jit`` and other JAX transformations, the size of the output must be specified statically using ``total_repeat_length``: >>> jit_repeat = jax.jit(jnp.repeat, static_argnames=['axis', 'total_repeat_length']) >>> jit_repeat(a, repeats, axis=1, total_repeat_length=5) Array([[1, 1, 2, 2, 2], [3, 3, 4, 4, 4]], dtype=int32) If `total_repeat_length` is smaller than ``sum(repeats)``, the result will be truncated: >>> jit_repeat(a, repeats, axis=1, total_repeat_length=4) Array([[1, 1, 2, 2], [3, 3, 4, 4]], dtype=int32) If it is larger, then the additional entries will be filled with the final value: >>> jit_repeat(a, repeats, axis=1, total_repeat_length=7) Array([[1, 1, 2, 2, 2, 2, 2], [3, 3, 4, 4, 4, 4, 4]], dtype=int32) rDNrz'axis' argument of jnp.repeat()zhjnp.repeat with a non-constant `repeats` is supported only when `total_repeat_length` is None. (repeats=z total_repeat_length=)zWhen jit-compiling jnp.repeat, the total number of repeats must be static. To fix this, either specify a static value for `repeats`, or pass a static value to `total_repeat_length`.rc g|] }|k| Srjrj)r*rDaux_axiss rKr2zrepeat..^sIIIQ1==q===rLrzf`repeat` with a scalar parameter `a` is only implemented for scalar values of the parameter `repeats`.rn)shiftrh)'r*rrrrrSrrrrFr^rrr}rEr?rOrrHr"rrrrr=rrrrr[rollrrr(rrrrtake) rrrbr input_shape aux_shape result_shapeexclusive_repeatsscatter_indicesblock_split_indicatorsgather_indicesrs @rKrDrDsBx###+gA$.xAA \ aA DD A 6W X X$ D#   '""c& b?FbbJ]bbb c cc $T7())G  ww1aA!HHk c+&6&6 7 7dh!%k!2!2ixD>LL 56!99---| < << 1XXd^q 1:: 7!,,,/266q99%&788/ "5!6eDDD14_EII!LL$%;<0`` refers to sub-diagonal above the main diagonal. dtype: optional, data type of the returned array. The default type is float. Returns: An array of shape ``(N, M)`` containing the lower triangle with elements below the sub-diagonal specified by ``k`` are set to one and zero elsewhere. See also: - :func:`jax.numpy.tril`: Returns a lower triangle of an array. - :func:`jax.numpy.triu`: Returns an upper triangle of an array. Examples: >>> jnp.tri(3) Array([[1., 0., 0.], [1., 1., 0.], [1., 1., 1.]], dtype=float32) When ``M`` is not equal to ``N``: >>> jnp.tri(3, 4) Array([[1., 0., 0., 0.], [1., 1., 0., 0.], [1., 1., 1., 0.]], dtype=float32) when ``k>0``: >>> jnp.tri(3, k=1) Array([[1., 1., 0.], [1., 1., 1.], [1., 1., 1.]], dtype=float32) When ``k<0``: >>> jnp.tri(3, 4, k=-1) Array([[0., 0., 0., 0.], [1., 0., 0., 0.], [1., 1., 0., 0.]], dtype=float32) tri)rrrr_tri)r ryrXrPs rKrrsHd #E5111 =aaa!  7%  51a&! , ,,rLrXcTtjd|t|}t|dkrt d|dd\}}t |||t }tjtj ||dd|t|S)ahReturn lower triangle of an array. JAX implementation of :func:`numpy.tril` Args: m: input array. Must have ``m.ndim >= 2``. k: k: optional, int, default=0. Specifies the sub-diagonal above which the elements of the array are set to zero. ``k=0`` refers to main diagonal, ``k<0`` refers to sub-diagonal below the main diagonal and ``k>0`` refers to sub-diagonal above the main diagonal. Returns: An array with same shape as input containing the upper triangle of the given array with elements below the sub-diagonal specified by ``k`` are set to zero. See also: - :func:`jax.numpy.triu`: Returns an upper triangle of an array. - :func:`jax.numpy.tri`: Returns an array with ones on and below the diagonal and zeros elsewhere. Examples: >>> x = jnp.array([[1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12]]) >>> jnp.tril(x) Array([[ 1, 0, 0, 0], [ 5, 6, 0, 0], [ 9, 10, 11, 0]], dtype=int32) >>> jnp.tril(x, k=1) Array([[ 1, 2, 0, 0], [ 5, 6, 7, 0], [ 9, 10, 11, 12]], dtype=int32) >>> jnp.tril(x, k=-1) Array([[ 0, 0, 0, 0], [ 5, 0, 0, 0], [ 9, 10, 0, 0]], dtype=int32) When ``m.ndim > 2``, ``jnp.tril`` operates batch-wise on the trailing axes. >>> x1 = jnp.array([[[1, 2], ... [3, 4]], ... [[5, 6], ... [7, 8]]]) >>> jnp.tril(x1) Array([[[1, 0], [3, 4]], [[5, 0], [7, 8]]], dtype=int32) trilrz.Argument to jax.numpy.tril must be at least 2DrNrXrP r*rr?rrrrNrrqrrrZrXm_shaper ryrs rKrrshvq!!! !HH'\\A E F FF $!Q QQd # # #$ CM$ 55q*Q-- H HHrLcZtjd|t|}t|dkrt d|dd\}}t |||dz t }tjtj ||ddt||S)aReturn upper triangle of an array. JAX implementation of :func:`numpy.triu` Args: m: input array. Must have ``m.ndim >= 2``. k: optional, int, default=0. Specifies the sub-diagonal below which the elements of the array are set to zero. ``k=0`` refers to main diagonal, ``k<0`` refers to sub-diagonal below the main diagonal and ``k>0`` refers to sub-diagonal above the main diagonal. Returns: An array with same shape as input containing the lower triangle of the given array with elements above the sub-diagonal specified by ``k`` are set to zero. See also: - :func:`jax.numpy.tril`: Returns a lower triangle of an array. - :func:`jax.numpy.tri`: Returns an array with ones on and below the diagonal and zeros elsewhere. Examples: >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9], ... [10, 11, 12]]) >>> jnp.triu(x) Array([[1, 2, 3], [0, 5, 6], [0, 0, 9], [0, 0, 0]], dtype=int32) >>> jnp.triu(x, k=1) Array([[0, 2, 3], [0, 0, 6], [0, 0, 0], [0, 0, 0]], dtype=int32) >>> jnp.triu(x, k=-1) Array([[ 1, 2, 3], [ 4, 5, 6], [ 0, 8, 9], [ 0, 0, 12]], dtype=int32) When ``m.ndim > 2``, ``jnp.triu`` operates batch-wise on the trailing axes. >>> x1 = jnp.array([[[1, 2], ... [3, 4]], ... [[5, 6], ... [7, 8]]]) >>> jnp.triu(x1) Array([[[1, 2], [0, 4]], [[5, 6], [0, 8]]], dtype=int32) triurz.Argument to jax.numpy.triu must be at least 2DrNrrrrs rKr r spvq!!! !HH'\\A E F FF $!Q QQU$ ' ' '$ CM$ 55z!}}a H HHrL)rrrPcjtjd||tdtj|dt |}t |||fd}tt|||||t|t|}tj |d|S)Ntracez1The 'out' argument to jnp.trace is not supported.rrrr) r*rrrrr?rrrrNrr(r)rr=rrrPrrs rKr r Xsw"""_ Q R RR#E7333 !HH'q5%.(++! C& E E E z!}}!  6 6 66rLcJtjdfd}|S)NFrcfdt|D}fd|D}td|i|DS)Nc Zg|]'\}}tjd|d|djd(S)Nz argument z of jnp.()rrrs)r*rDargrs rKr2z;_wrap_indices_function..wrapper..msY + + +3  "C>Q>> >>> @ @ + + +rLc \i|](\}}|tjd|d|djd)S)Nz argument 'z ' of jnp.rr)r*keyrrs rK z;_wrap_indices_function..wrapper..ps[...#s4)cDDDajDDDFF...rLc34K|]}t|VdSr`rrs rKr,z:_wrap_indices_function..wrapper..ss(88888888rL)ritemsrG)rrrs rKwrapperz'_wrap_indices_function..wrapperks + + + +#D// + + +D....$llnn...F 88QQ%7%7%7888 8 88rL)r*r)rrs` rK_wrap_indices_functionrjs=?1'''9999('9 .rLc|dkr||zt||d|z z S||krdSt|||z }||dzzdz|||z |z zzS)Nrrr) _triu_sizer)rrZrXmks rKrrysnUU q5:aQU,, ,,Avv 1 QAB a=A a!ebj 1 11rLcTtjtj|d}tjtj|d}||ntjtj|d}t t t ||f|t|||\}}||fS)aReturn the indices of upper triangle of an array of size ``(n, m)``. JAX implementation of :func:`numpy.triu_indices`. Args: n: int. Number of rows of the array for which the indices are returned. k: optional, int, default=0. Specifies the sub-diagonal on and above which the indices of upper triangle are returned. ``k=0`` refers to main diagonal, ``k<0`` refers to sub-diagonal below the main diagonal and ``k>0`` refers to sub-diagonal above the main diagonal. m: optional, int. Number of columns of the array for which the indices are returned. If not specified, then ``m = n``. Returns: A tuple of two arrays containing the indices of the upper triangle, one along each axis. See also: - :func:`jax.numpy.tril_indices`: Returns the indices of lower triangle of an array of size ``(n, m)``. - :func:`jax.numpy.triu_indices_from`: Returns the indices of upper triangle of a given array. - :func:`jax.numpy.tril_indices_from`: Returns the indices of lower triangle of a given array. Examples: If only ``n`` is provided in input, the indices of upper triangle of an array of size ``(n, n)`` array are returned. >>> jnp.triu_indices(3) (Array([0, 0, 0, 1, 1, 2], dtype=int32), Array([0, 1, 2, 1, 2, 2], dtype=int32)) If both ``n`` and ``m`` are provided in input, the indices of upper triangle of an ``(n, m)`` array are returned. >>> jnp.triu_indices(3, m=2) (Array([0, 0, 1], dtype=int32), Array([0, 1, 1], dtype=int32)) If ``k = 1``, the indices on and above the first sub-diagonal above the main diagonal are returned. >>> jnp.triu_indices(3, k=1) (Array([0, 0, 1], dtype=int32), Array([1, 2, 2], dtype=int32)) If ``k = -1``, the indices on and above the first sub-diagonal below the main diagonal are returned. >>> jnp.triu_indices(3, k=-1) (Array([0, 0, 0, 1, 1, 1, 2, 2], dtype=int32), Array([0, 1, 2, 0, 1, 2, 1, 2], dtype=int32)) n argument of jnp.triu_indicesk argument of jnp.triu_indicesNm argument of jnp.triu_indicesrr)rrrrrdr rNrrrXrZrDrs rK triu_indicesr$sf X^Q0PQQ! X^Q0PQQ! 9aa$0Ddee! dAq6lla(((z!Q/B/B C C C$!Q A+rLcVtjtj|d}tjtj|d}||ntjtj|d}t t t ||f|t||| \}}||fS)aReturn the indices of lower triangle of an array of size ``(n, m)``. JAX implementation of :func:`numpy.tril_indices`. Args: n: int. Number of rows of the array for which the indices are returned. k: optional, int, default=0. Specifies the sub-diagonal on and below which the indices of lower triangle are returned. ``k=0`` refers to main diagonal, ``k<0`` refers to sub-diagonal below the main diagonal and ``k>0`` refers to sub-diagonal above the main diagonal. m: optional, int. Number of columns of the array for which the indices are returned. If not specified, then ``m = n``. Returns: A tuple of two arrays containing the indices of the lower triangle, one along each axis. See also: - :func:`jax.numpy.triu_indices`: Returns the indices of upper triangle of an array of size ``(n, m)``. - :func:`jax.numpy.triu_indices_from`: Returns the indices of upper triangle of a given array. - :func:`jax.numpy.tril_indices_from`: Returns the indices of lower triangle of a given array. Examples: If only ``n`` is provided in input, the indices of lower triangle of an array of size ``(n, n)`` array are returned. >>> jnp.tril_indices(3) (Array([0, 1, 1, 2, 2, 2], dtype=int32), Array([0, 0, 1, 0, 1, 2], dtype=int32)) If both ``n`` and ``m`` are provided in input, the indices of lower triangle of an ``(n, m)`` array are returned. >>> jnp.tril_indices(3, m=2) (Array([0, 1, 1, 2, 2], dtype=int32), Array([0, 0, 1, 0, 1], dtype=int32)) If ``k = 1``, the indices on and below the first sub-diagonal above the main diagonal are returned. >>> jnp.tril_indices(3, k=1) (Array([0, 0, 1, 1, 1, 2, 2, 2], dtype=int32), Array([0, 1, 0, 1, 2, 0, 1, 2], dtype=int32)) If ``k = -1``, the indices on and below the first sub-diagonal below the main diagonal are returned. >>> jnp.tril_indices(3, k=-1) (Array([1, 2, 2], dtype=int32), Array([0, 0, 1], dtype=int32)) rr Nr!rr")rrrrrdrrNrr#s rK tril_indicesr&sf X^Q0PQQ! X^Q0PQQ! 9aa$0Ddee! dAq6lla(((z!Q/C/C D D D$!Q A+rLct|}t|dkrtdt|d||dS)aReturn the indices of upper triangle of a given array. JAX implementation of :func:`numpy.triu_indices_from`. Args: arr: input array. Must have ``arr.ndim == 2``. k: optional, int, default=0. Specifies the sub-diagonal on and above which the indices of upper triangle are returned. ``k=0`` refers to main diagonal, ``k<0`` refers to sub-diagonal below the main diagonal and ``k>0`` refers to sub-diagonal above the main diagonal. Returns: A tuple of two arrays containing the indices of the upper triangle, one along each axis. See also: - :func:`jax.numpy.tril_indices_from`: Returns the indices of lower triangle of a given array. - :func:`jax.numpy.triu_indices`: Returns the indices of upper triangle of an array of size ``(n, m)``. - :func:`jax.numpy.triu`: Return an upper triangle of an array. Examples: >>> arr = jnp.array([[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9]]) >>> jnp.triu_indices_from(arr) (Array([0, 0, 0, 1, 1, 2], dtype=int32), Array([0, 1, 2, 1, 2, 2], dtype=int32)) Elements indexed by ``jnp.triu_indices_from`` correspond to those in the output of ``jnp.triu``. >>> ind = jnp.triu_indices_from(arr) >>> arr[ind] Array([1, 2, 3, 5, 6, 9], dtype=int32) >>> jnp.triu(arr) Array([[1, 2, 3], [0, 5, 6], [0, 0, 9]], dtype=int32) When ``k > 0``: >>> jnp.triu_indices_from(arr, k=1) (Array([0, 0, 1], dtype=int32), Array([1, 2, 2], dtype=int32)) When ``k < 0``: >>> jnp.triu_indices_from(arr, k=-1) (Array([0, 0, 0, 1, 1, 1, 2, 2], dtype=int32), Array([0, 1, 2, 0, 1, 2, 1, 2], dtype=int32)) rOnly 2-D inputs are acceptedrrrXrZ)r?rrr$rrX arr_shapes rKtriu_indices_fromr,MfCjj)^^q 3 4 44 ila9Q< 8 8 88rLct|}t|dkrtdt|d||dS)aReturn the indices of lower triangle of a given array. JAX implementation of :func:`numpy.tril_indices_from`. Args: arr: input array. Must have ``arr.ndim == 2``. k: optional, int, default=0. Specifies the sub-diagonal on and below which the indices of upper triangle are returned. ``k=0`` refers to main diagonal, ``k<0`` refers to sub-diagonal below the main diagonal and ``k>0`` refers to sub-diagonal above the main diagonal. Returns: A tuple of two arrays containing the indices of the lower triangle, one along each axis. See also: - :func:`jax.numpy.triu_indices_from`: Returns the indices of upper triangle of a given array. - :func:`jax.numpy.tril_indices`: Returns the indices of lower triangle of an array of size ``(n, m)``. - :func:`jax.numpy.tril`: Returns a lower triangle of an array Examples: >>> arr = jnp.array([[1, 2, 3], ... [4, 5, 6], ... [7, 8, 9]]) >>> jnp.tril_indices_from(arr) (Array([0, 1, 1, 2, 2, 2], dtype=int32), Array([0, 0, 1, 0, 1, 2], dtype=int32)) Elements indexed by ``jnp.tril_indices_from`` correspond to those in the output of ``jnp.tril``. >>> ind = jnp.tril_indices_from(arr) >>> arr[ind] Array([1, 4, 5, 7, 8, 9], dtype=int32) >>> jnp.tril(arr) Array([[1, 0, 0], [4, 5, 0], [7, 8, 9]], dtype=int32) When ``k > 0``: >>> jnp.tril_indices_from(arr, k=1) (Array([0, 0, 1, 1, 1, 2, 2, 2], dtype=int32), Array([0, 1, 0, 1, 2, 0, 1, 2], dtype=int32)) When ``k < 0``: >>> jnp.tril_indices_from(arr, k=-1) (Array([1, 2, 2], dtype=int32), Array([0, 0, 1], dtype=int32)) rr(rrr))r?rrr&r*s rKtril_indices_fromr/0r-rL)inplacerr0cT|rtd|rtdtjd|tt|}jdkrt djdkr7t fdjddDst d tj}t|j}j | |jd kr|n!t| |S) aReturn a copy of the array with the diagonal overwritten. JAX implementation of :func:`numpy.fill_diagonal`. The semantics of :func:`numpy.fill_diagonal` 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: input array. Must have ``a.ndim >= 2``. If ``a.ndim >= 3``, then all dimensions must be the same size. val: scalar or array with which to fill the diagonal. If an array, it will be flattened and repeated to fill the diagonal entries. 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 the diagonal set to ``val``. Examples: >>> x = jnp.zeros((3, 3), dtype=int) >>> jnp.fill_diagonal(x, jnp.array([1, 2, 3]), inplace=False) Array([[1, 0, 0], [0, 2, 0], [0, 0, 3]], dtype=int32) Unlike :func:`numpy.fill_diagonal`, the input ``x`` is not modified. If the diagonal value has too many entries, it will be truncated >>> jnp.fill_diagonal(x, jnp.arange(100, 200), inplace=False) Array([[100, 0, 0], [ 0, 101, 0], [ 0, 0, 102]], dtype=int32) If the diagonal has too few entries, it will be repeated: >>> x = jnp.zeros((4, 4), dtype=int) >>> jnp.fill_diagonal(x, jnp.array([3, 4]), inplace=False) Array([[3, 0, 0, 0], [0, 4, 0, 0], [0, 0, 3, 0], [0, 0, 0, 4]], dtype=int32) For non-square arrays, the diagonal of the leading square slice is filled: >>> x = jnp.zeros((3, 5), dtype=int) >>> jnp.fill_diagonal(x, 1, inplace=False) Array([[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0]], dtype=int32) And for square N-dimensional arrays, the N-dimensional diagonal is filled: >>> y = jnp.zeros((2, 2, 2)) >>> jnp.fill_diagonal(y, 1, inplace=False) Array([[[1., 0.], [0., 0.]], [[0., 0.], [0., 1.]]], dtype=float32) z0JAX arrays are immutable, must use inplace=Falsez1wrap=True is not implemented, must use wrap=False fill_diagonalrzarray must be at least 2-dc3:K|]}|jdkVdSrr))r*rrs rKr,z fill_diagonal..s-AAAOAAAAAArLrN/All dimensions of input must be of equal lengthr)rr*rrSrErrr?r diag_indicesrr _tile_to_sizer)rrrr0rrps` rKr2r2isB R P Q QQ S Q R RR3/// ajj! #VaZZ 1 2 22VaZZAAAAQWQRR[AAAAAZ F G GG !'ll!Q# cch!mmsssyy{{A1N1N O OOrLrEc^tjtj|d}tjtj|d}|dkr"t d||dkr"t d|t jt|f|zS)Nz"'n' argument of jnp.diag_indices()z%'ndim' argument of jnp.diag_indices()rz6n argument to diag_indices must be nonnegative, got {}z9ndim argument to diag_indices must be nonnegative, got {}) rrrrrr rrr)rrEs rKr5r5s X^Q0TUU! 6] ^ ^$UU MfQii ! !! AXX PfTll $ $$ (4    $$rLcRtjd|t|}t|dkstdt |}t t t |dkrtdt|d|S)Ndiag_indices_fromrz input array must be at least 2-drr4rr)r*rrErr?rrr5)rrrs rKr9r9s*C000 Cyy" ca 7 8 88 Cjj!U3ZZQ F G GG ad $ $ $$rL)r=rrc <tjd|t|}t|dkrt dt jtj|d}t|||fd}tdt||t|dz||t|dz }t|}tt|t||z}|dkr |d||fn |d||fS)Ndiagonalrz6diagonal requires an array of at least two dimensions.z#'offset' argument of jnp.diagonal()r r.)r*rr?rErrrrrrrrrr0)rr=rrr diag_sizerDrs rKr;r;sz1%%% !HH' !WWq[[ M N NN  !(.&:_ ` `&q5%.(++!!S#fa..8 #fa..8::;;) Y! S[[#f++ 122!1319!CAI,6rLcFt|tj|Sr`)_diagrr)rrXs rKdiagr?s q(.## $ $$rLc tjd|t|}t|dkrd}|dt |z}t j|||td|td| dff}tt||t|t|St|dkrt||Std) Nr?rc0tj|ddS)Nrjr)r?rZ)rr?rZs rKrz_diag..sS]1B1===rLrrr)r=zdiag input must be 1d or 2d)r*rr?rr0rr"rrrrNrr;r)rrXv_shaperrs rKr>r>svq!!! !HH'\\Q = =D SVVA 4477c!QiiQQ79::A Q!4(((!Z]] ; ;; 7||q Aa  2 3 33rLzThis differs from np.diagflat for some scalar values of v, jax always returns a two-dimensional array, whereas numpy may return a scalar depending on the type of v. ctjd|t|}t|}|t |z}t ||z|j}td|t |z }|dkr ||z||zz}n |||z |zz}|j| |}| ||}|S)Ndiagflatrnr) r*rrrr0rrPrrrr=)rrXv_ravelv_length adj_lengthrrDfis rKrDrDsz1%%% !HH' \\(#a&& * j#7=999# Q 3q66!""!1ff 1Qz\ BB AaC  B r w# J ++# *rLfbctjt|d}|dk}tj|rt dt |Sd|vrt|nd}d|vrt|dddnd}||t||z S)Nz2Error arose in the `filt` argument of trim_zeros()rrrr) rrrSr(rrwr[lowerargminr)filttrimnzrrs rK trim_zerosrPs 8 : :$  "^B" F4LL ! !!tzz||++&***%4::<<//r$$B$xQ# eCIIO# $$rLctjt|d}tj||k}t j|rtdt|Sd| vrt|nd}d| vrt|dddnd}||t||z S)Nz6Error arose in the `filt` argument of trim_zeros_tol()rrrr) rrrSr)r0r(rrwr[rKrLr)rMtolrNrOrrs rKtrim_zeros_tolrSs < > >$ 43"^B" F4LL ! !!tzz||++&***%4::<<//r$$B$xQ# eCIIO# $$rLvaluesc|,tt|t|gdSt||g|S)aReturn a new array with values appended to the end of the original array. JAX implementation of :func:`numpy.append`. Args: arr: original array. values: values to be appended to the array. The ``values`` must have the same number of dimensions as ``arr``, and all dimensions must match except in the specified axis. axis: axis along which to append values. If None (default), both ``arr`` and ``values`` will be flattened before appending. Returns: A new array with values appended to ``arr``. See also: - :func:`jax.numpy.insert` - :func:`jax.numpy.delete` Examples: >>> a = jnp.array([1, 2, 3]) >>> b = jnp.array([4, 5, 6]) >>> jnp.append(a, b) Array([1, 2, 3, 4, 5, 6], dtype=int32) Appending along a specific axis: >>> a = jnp.array([[1, 2], ... [3, 4]]) >>> b = jnp.array([[5, 6]]) >>> jnp.append(a, b, axis=0) Array([[1, 2], [3, 4], [5, 6]], dtype=int32) Appending along a trailing axis: >>> a = jnp.array([[1, 2, 3], ... [4, 5, 6]]) >>> b = jnp.array([[7], [8]]) >>> jnp.append(a, b, axis=1) Array([[1, 2, 3, 7], [4, 5, 6, 8]], dtype=int32) Nrrh)rr)rrTrbs rKr8r8%sB` \ c E&MM2A 6 66 V}4 0 0 00rL)assume_unique_indicesArrayLike | slicerVc tjd||t|}d}t|}t ||j} t j|}t ||j|}tdt|D}t||td|fz||t|dzdfzg|S#t$rYnwxYwt|tr"t|j||}d}tjd||t!t#|t$r|rt|}t't)|dk||j|z|d|j|}t+|}|tt-|z}t|j||jz }||dddf|dddfkdz }|tdf|z|fzSt3jt6j|d}t!|jt$r,t7j|j|t< }d ||<nR|jt<kr*|j|j|fkrt?d |}nt?d |jd |tdt|D|fzS)aDelete entry or entries from an array. JAX implementation of :func:`numpy.delete`. Args: arr: array from which entries will be deleted. obj: index, indices, or slice to be deleted. axis: axis along which entries will be deleted. assume_unique_indices: In case of array-like integer (not boolean) indices, assume the indices are unique, and perform the deletion in a way that is compatible with JIT and other JAX transformations. Returns: Copy of ``arr`` with specified indices deleted. Note: ``delete()`` usually requires the index specification to be static. If the index is an integer array that is guaranteed to contain unique entries, you may specify ``assume_unique_indices=True`` to perform the operation in a manner that does not require static indices. Examples: Delete entries from a 1D array: >>> a = jnp.array([4, 5, 6, 7, 8, 9]) >>> jnp.delete(a, 2) Array([4, 5, 7, 8, 9], dtype=int32) >>> jnp.delete(a, slice(1, 4)) # delete a[1:4] Array([4, 8, 9], dtype=int32) >>> jnp.delete(a, slice(None, None, 2)) # delete a[::2] Array([5, 7, 9], dtype=int32) Delete entries from a 2D array along a specified axis: >>> a2 = jnp.array([[4, 5, 6], ... [7, 8, 9]]) >>> jnp.delete(a2, 1, axis=1) Array([[4, 6], [7, 9]], dtype=int32) Delete multiple entries via a sequence of indices: >>> indices = jnp.array([0, 1, 3]) >>> jnp.delete(a, indices) Array([6, 8, 9], dtype=int32) This will fail under :func:`~jax.jit` and other transformations, because the output shape cannot be known with the possibility of duplicate indices: >>> jax.jit(jnp.delete)(a, indices) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ... ConcretizationTypeError: Abstract tracer value encountered where concrete value is expected: traced array with shape int32[3]. If you can ensure that the indices are unique, pass ``assume_unique_indices`` to allow this to be executed under JIT: >>> jit_delete = jax.jit(jnp.delete, static_argnames=['assume_unique_indices']) >>> jit_delete(a, indices, assume_unique_indices=True) Array([6, 8, 9], dtype=int32) deleteNrc34K|]}tdVdSr`rrs rKr,zdelete..s(11d 111111rLrrhTz$'obj' array argument of jnp.delete()rnFzjnp.delete(arr, obj): for boolean indices, obj must be one-dimensional with length matching specified axis.z#np.delete(arr, obj): got obj.dtype=z; must be integer or bool.c34K|]}tdVdSr`r[rs rKr,zdelete..s(22t222222rL) r*rrrSrOrErrr?rGrrrrxrFrrTr[rrrsortrrrrrr}rPrNrNr) rrrbrVrrprD obj_arrayrs rKrYrY[s*Hx%%% \ **C D cll! D!& ) )$a .  C S!'$- 0 0C 11U4[[111 1 1C #q# 0011SE#'4 ? ?? :DD f9?fff g gg 522eDkk222 2 2dW < ==s/C)) C65C6ctjd|t|trdn||t |}t |}|t |}d}t jd|d}t||j }t|tr(t| |j |}nt |}|j dkrtd|tj|jtjsM|jdkr0t|t&s|t*}ntd|t-||j |jd}|jdkrLt |d}|j dkrt/|d|}t1|j ||}|j |}t3|j |j |fd} t5|j } | |xx| z cc<t7|t9|  } t;|dk||z|}t=|d|}|jtA|!t| |j } tE|| ztF j| $d} t;| | d}| jtdf|z| fz$|} | jtdf|z|fz$|} | S) Nr"rzaxis argument of jnp.insert()rzMjnp.insert(): obj must be a slice, a one-dimensional array, or a scalar; got z5jnp.insert(): index array must be integer typed; got F)rrPrr)rnr")%r*rrFrrSrrrrOrErrr?rr}rTrPrrr,rr^rrrrxrHrrGrrrargsortrrNrNr)rrrTrbr values_arrrrn_inputn_insert out_shaper values_indarr_maskarr_inds rKr"r"s.x:c5+A+A&JaasFSSS cll!v* \ aA D d,K L L$ D!& ) )$Uckk!'$-001GGcllG \A 60366 7 77 w}bj 1 14|qC!7!7s##gg 3-033 4 44ZqvQW5III* \Q 'NN1 E|qJ400j:#D)511G GDM' gmj.>t.D-F G G J(17mm) D///X///1E),,---# 'A+w0' : :' !W % %'z''**+//xw}0U0U0UVV* 'H$D 1 1 1 4Z @ D DU K K( ( ) ) )! ,' d ~$ }4599*EE# d ~$z1266q99# *rLfunc1drc@tjd|t|}t||}fd}t d||z D]}t j||d}t |D]}t j|dd}||S)Nrjc|gRiSr`rj)rrrhrs rKrz"apply_along_axis..s!VVC1$111&11rLrr)rqout_axesr)r*rrErOrrr)rhrbrrrnum_dimsrgrDs` `` rKrjrj s)3/// #YY( D( + +$ 1 1 1 1 1 1$ HtO $ $22a 8D!b 1 1 1DD ;;11a 8D!a 0 0 0DD crL!Callable[[ArrayLike, int], Array]ctjd|t|}|D]S}|||}|j|jkr|}!|j|jdz krt ||}Et d|S)Napply_over_axesrz7function is not returning an array of the correct shape)r*rrSrErr)rgrrJa_arrrbrs rKroros(!,,, !**%RRd UDAvee 5:> ! !!T""ee P Q QQ ,rLcFtjd||tj|dt |t |}}|tj||d\}}nd}d}t |t |}}|dks|dkrB|*||}||}tj ||}n6|dkr |dz fd f} n |dz f|d z ff} tj ||| |f|| }tj |||S) a Compute the dot product of two arrays. JAX implementation of :func:`numpy.dot`. This differs from :func:`jax.numpy.matmul` in two respects: - if either ``a`` or ``b`` is a scalar, the result of ``dot`` is equivalent to :func:`jax.numpy.multiply`, while the result of ``matmul`` is an error. - if ``a`` and ``b`` have more than 2 dimensions, the batch indices are stacked rather than broadcast. Args: a: first input array, of shape ``(..., N)``. b: second input array. Must have shape ``(N,)`` or ``(..., N, M)``. In the multi-dimensional case, leading dimensions must be broadcast-compatible with the leading dimensions of ``a``. precision: either ``None`` (default), which means the default precision for the backend, a :class:`~jax.lax.Precision` enum value (``Precision.DEFAULT``, ``Precision.HIGH`` or ``Precision.HIGHEST``) or a tuple of two such values indicating precision of ``a`` and ``b``. preferred_element_type: either ``None`` (default), which means the default accumulation type for the input types, or a datatype, indicating to accumulate results to and return a result with that datatype. Returns: array containing the dot product of the inputs, with batch dimensions of ``a`` and ``b`` stacked rather than broadcast. See also: - :func:`jax.numpy.matmul`: broadcasted batched matmul. - :func:`jax.lax.dot_general`: general batched matrix multiplication. Examples: For scalar inputs, ``dot`` computes the element-wise product: >>> x = jnp.array([1, 2, 3]) >>> jnp.dot(x, 2) Array([2, 4, 6], dtype=int32) For vector or matrix inputs, ``dot`` computes the vector or matrix product: >>> M = jnp.array([[2, 3, 4], ... [5, 6, 7], ... [8, 9, 0]]) >>> jnp.dot(M, x) Array([20, 38, 26], dtype=int32) >>> jnp.dot(M, M) Array([[ 51, 60, 29], [ 96, 114, 62], [ 61, 78, 95]], dtype=int32) For higher-dimensional matrix products, batch dimensions are stacked, whereas in :func:`~jax.numpy.matmul` they are broadcast. For example: >>> a = jnp.zeros((3, 2, 4)) >>> b = jnp.zeros((3, 4, 1)) >>> jnp.dot(a, b).shape (3, 2, 3, 1) >>> jnp.matmul(a, b).shape (3, 2, 1) dotNTreturn_weak_type_flagFrjrjrrr~r)dimension_numbersrr) r*rrrrSrrErrr1 dot_generalrr ) rrrroutput_weak_type batch_dimsa_ndimb_ndimr contract_dimss rKrrrr*sKBua####$:EBBB WQZZQ!#/5/A!Q^b/c/c/c,,,*77DGG&& q[[FaKK) (() * *a (() * *a WQ]]FF {{ }d+mm }vzm4m _QmZ5P'0I_aaaF  +F4JL\ ] ]]rLc  tjd||tj|dt |t |}}t ||fD]<\}}t |dkr$d|dt |}t|=|tj||d\}}nd}t |dkt |dk} }|rt|dd nd } | rt|dd nd } tt| t| } d | t| z z| z} d | t| z z| z} g} g}g}g}g}g}g}t t| | D]\}\}}|| |!|| |9tj|drX| || t|t|zt| ztj|drY| || t|t|zt|ztj||r{| t|t|z| t|t|z| |td t|t||r| | | r| | |zt#jt#j|||g}t)j|t-| }t)j|t-|}t)j||t |dz ft |dz | z ff||ff|| }t)j||}t3j|||S)agPerform a matrix multiplication. JAX implementation of :func:`numpy.matmul`. Args: a: first input array, of shape ``(..., N)``. b: second input array. Must have shape ``(N,)`` or ``(..., N, M)``. In the multi-dimensional case, leading dimensions must be broadcast-compatible with the leading dimensions of ``a``. precision: either ``None`` (default), which means the default precision for the backend, a :class:`~jax.lax.Precision` enum value (``Precision.DEFAULT``, ``Precision.HIGH`` or ``Precision.HIGHEST``) or a tuple of two such values indicating precision of ``a`` and ``b``. preferred_element_type: either ``None`` (default), which means the default accumulation type for the input types, or a datatype, indicating to accumulate results to and return a result with that datatype. Returns: array containing the matrix product of the inputs. Shape is ``a.shape[:-1]`` if ``b.ndim == 1``, otherwise the shape is ``(..., M)``, where leading dimensions of ``a`` and ``b`` are broadcast together. See Also: - :func:`jax.numpy.linalg.vecdot`: batched vector product. - :func:`jax.numpy.linalg.tensordot`: batched tensor product. - :func:`jax.lax.dot_general`: general N-dimensional batched dot product. Examples: Vector dot products: >>> a = jnp.array([1, 2, 3]) >>> b = jnp.array([4, 5, 6]) >>> jnp.matmul(a, b) Array(32, dtype=int32) Matrix dot product: >>> a = jnp.array([[1, 2, 3], ... [4, 5, 6]]) >>> b = jnp.array([[1, 2], ... [3, 4], ... [5, 6]]) >>> jnp.matmul(a, b) Array([[22, 28], [49, 64]], dtype=int32) For convenience, in all cases you can do the same computation using the ``@`` operator: >>> a @ b Array([[22, 28], [49, 64]], dtype=int32) matmulrzmatmul input operand z, must have ndim at least 1, but it has ndim NTrsFrrjr`z3Incompatible shapes for matmul arguments: {} and {}r)r*rrrrSrrErrr?rrrr8rdefinitely_equalr r}r`rrrrGrwrrr )rrrrrDrMrnrxa_is_matb_is_mat a_batch_dims b_batch_dimsnum_batch_dims a_squeeze b_squeezea_batchb_batch idx_batch idx_a_other idx_b_otherbabbrarrs rKr~r~sxtxA&&&#$:HEEE WQZZQ!Ada Aww{{*Q** $Q**c sOO#/5/A!Q^b/c/c/c,,,Q! tAww{H(:B)Jq#2#,:B)Jq#2#,s<((#l*;*;<<.NS->->>?,N,NS->->>?,N,)) ' ')++s<>>??44ka"b z  r1 % % 4s9~~K(8(883y>>IJJJJ r1 % % 4s9~~K(8(883y>>IJJJJ r2 & &4 nnS^^c+&6&66777 nnS^^c+&6&66777q LuQxxq22 4 441{!!.111 <{!!.8";<<< BNI{K#HII J J$ k!U9%%&&! k!U9%%&&! qT!WWq[NT!WWq[835 6'8J K0F H H H# =d # #&  +F4JL\ ] ]]rLctjd||tt|trt j|}tt|t|||S)aPerform a conjugate multiplication of two 1D vectors. JAX implementation of :func:`numpy.vdot`. Args: a: first input array, if not 1D it will be flattened. b: second input array, if not 1D it will be flattened. Must have ``a.size == b.size``. precision: either ``None`` (default), which means the default precision for the backend, a :class:`~jax.lax.Precision` enum value (``Precision.DEFAULT``, ``Precision.HIGH`` or ``Precision.HIGHEST``) or a tuple of two such values indicating precision of ``a`` and ``b``. preferred_element_type: either ``None`` (default), which means the default accumulation type for the input types, or a datatype, indicating to accumulate results to and return a result with that datatype. Returns: Scalar array (shape ``()``) containing the conjugate vector product of the inputs. See Also: - :func:`jax.numpy.vecdot`: batched vector product. - :func:`jax.numpy.matmul`: general matrix multiplication. - :func:`jax.lax.dot_general`: general N-dimensional batched dot product. Examples: >>> x = jnp.array([1j, 2j, 3j]) >>> y = jnp.array([1., 2., 3.]) >>> jnp.vdot(x, y) Array(0.-14.j, dtype=complex64) Note the difference between this and :func:`~jax.numpy.dot`, which does not conjugate the first input when complex: >>> jnp.dot(x, y) Array(0.+14.j, dtype=complex64) vdotr) r*rrTr[rUr)rrrrrrrrs rKrrskRvq!$$$q ?++ AA U1XXuQxx9$: < < <>> a = jnp.array([1j, 2j, 3j]) >>> b = jnp.array([4., 5., 6.]) >>> jnp.linalg.vecdot(a, b) Array(0.-32.j, dtype=complex64) Batched vector dot product of two 2D arrays: >>> a = jnp.array([[1, 2, 3], ... [4, 5, 6]]) >>> b = jnp.array([[2, 3, 4]]) >>> jnp.linalg.vecdot(a, b, axis=-1) Array([20, 47], dtype=int32) z jnp.vecdotzaxes must match; got shapes rz with axis=rrz (n),(n)->()) signature) r*rrSr?rrrrr+rr)rrrbrrx1_arrx2_arrs rKvecdotr1sZ|R,,,2;; && \$6<--- bFLbbv|bb[_bb c cc 9  fdB / /& 9  fdB / /& ,749Mcddd* , , ,,2F < <>> x1 = jnp.arange(24.).reshape(2, 3, 4) >>> x2 = jnp.ones((3, 4, 5)) >>> jnp.tensordot(x1, x2) Array([[ 66., 66., 66., 66., 66.], [210., 210., 210., 210., 210.]], dtype=float32) Equivalent result when specifying the axes as explicit sequences: >>> jnp.tensordot(x1, x2, axes=([1, 2], [0, 1])) Array([[ 66., 66., 66., 66., 66.], [210., 210., 210., 210., 210.]], dtype=float32) Equivalent result via :func:`~jax.numpy.einsum`: >>> jnp.einsum('ijk,jkm->im', x1, x2) Array([[ 66., 66., 66., 66., 66.], [210., 210., 210., 210., 210.]], dtype=float32) Setting ``axes=1`` for two-dimensional inputs is equivalent to a matrix multiplication: >>> x1 = jnp.array([[1, 2], ... [3, 4]]) >>> x2 = jnp.array([[1, 2, 3], ... [4, 5, 6]]) >>> jnp.linalg.tensordot(x1, x2, axes=1) Array([[ 9, 12, 15], [19, 26, 33]], dtype=int32) >>> x1 @ x2 Array([[ 9, 12, 15], [19, 26, 33]], dtype=int32) Setting ``axes=0`` for one-dimensional inputs is equivalent to :func:`~jax.numpy.outer`: >>> x1 = jnp.array([1, 2]) >>> x2 = jnp.array([1, 2, 3]) >>> jnp.linalg.tensordot(x1, x2, axes=0) Array([[1, 2, 3], [2, 4, 6]], dtype=int32) >>> jnp.outer(x1, x2) Array([[1, 2, 3], [2, 4, 6]], dtype=int32) tensordotNTrsFzBNumber of tensordot axes (axes {}) exceeds input ranks ({} and {})rzBtensordot requires axes lists to have equal length, got {} and {}.c38K|]}t|VdSr`rO)r*rDrzs rKr,ztensordot...KK! 21f = =KKKKKKrLc38K|]}t|VdSr`r)r*rDr{s rKr,ztensordot..rrLzTtensordot requires both axes lists to be either ints, tuples or lists, got {} and {}zZtensordot axes argument must be an int, a pair of ints, or a pair of lists/tuples of ints.rur)r*rrrrSrErrQr^rrxr r?rGrrFrHrrOrrwrr ) rrrJrrrxrncontracting_dimsr_r`rrzr{s @@rKrrhsV{Aq)))#$:KHHH WQZZQ! 77& 77&#/5/A!Q^b/c/c/c,,, $ZZ3 c&&!!!! Pc cjjqw88 9 99U6D=&99::E%++>HC CyyDII$$$$$$$$$-c6::<-c6::<> C% ' ' ,JsUDM,J,J , SSXX  R 3,,---KKKKsKKKKKKKKKsKKKKKM$c cjjc** + ++ &C C.. ?1a"2H!=%.G] _ _ _&  +F4JL\ ] ]]rLceZdZdZdZdS) UnoptimizedzUnoptimized path for einsum.c.dgt|dz zS)NrYrr/)rbinputsrrs rKrozUnoptimized.__call__s 8s6{{Q ''rLN)rsrtru__doc__rorjrLrKrrs)$$(((((rLroptimal)roptimizerr _dot_general subscriptoperandsr"str | bool | list[tuple[int, ...]]rcdSr`rj)rrrrrrrs rKeinsumrs  CrL Sequence[Any]ArrayLike | Sequence[Any]cdSr`rj)rrJrrrrrrs rKrrs  CrLc$|g|R}|tdt|dtr|dnd}|durdn|durtn|}d|D} | s tj} n>> M = jnp.arange(16).reshape(4, 4) >>> x = jnp.arange(4) >>> y = jnp.array([5, 4, 3, 2]) **Vector product** >>> jnp.einsum('i,i', x, y) Array(16, dtype=int32) >>> jnp.vecdot(x, y) Array(16, dtype=int32) Here are some alternative ``einsum`` calling conventions to compute the same result: >>> jnp.einsum('i,i->', x, y) # explicit form Array(16, dtype=int32) >>> jnp.einsum(x, (0,), y, (0,)) # implicit form via indices Array(16, dtype=int32) >>> jnp.einsum(x, (0,), y, (0,), ()) # explicit form via indices Array(16, dtype=int32) **Matrix product** >>> jnp.einsum('ij,j->i', M, x) # explicit form Array([14, 38, 62, 86], dtype=int32) >>> jnp.matmul(M, x) Array([14, 38, 62, 86], dtype=int32) Here are some alternative ``einsum`` calling conventions to compute the same result: >>> jnp.einsum('ij,j', M, x) # implicit form Array([14, 38, 62, 86], dtype=int32) >>> jnp.einsum(M, (0, 1), x, (1,), (0,)) # explicit form via indices Array([14, 38, 62, 86], dtype=int32) >>> jnp.einsum(M, (0, 1), x, (1,)) # implicit form via indices Array([14, 38, 62, 86], dtype=int32) **Outer product** >>> jnp.einsum("i,j->ij", x, y) Array([[ 0, 0, 0, 0], [ 5, 4, 3, 2], [10, 8, 6, 4], [15, 12, 9, 6]], dtype=int32) >>> jnp.outer(x, y) Array([[ 0, 0, 0, 0], [ 5, 4, 3, 2], [10, 8, 6, 4], [15, 12, 9, 6]], dtype=int32) Some other ways of computing outer products: >>> jnp.einsum("i,j", x, y) # implicit form Array([[ 0, 0, 0, 0], [ 5, 4, 3, 2], [10, 8, 6, 4], [15, 12, 9, 6]], dtype=int32) >>> jnp.einsum(x, (0,), y, (1,), (0, 1)) # explicit form via indices Array([[ 0, 0, 0, 0], [ 5, 4, 3, 2], [10, 8, 6, 4], [15, 12, 9, 6]], dtype=int32) >>> jnp.einsum(x, (0,), y, (1,)) # implicit form via indices Array([[ 0, 0, 0, 0], [ 5, 4, 3, 2], [10, 8, 6, 4], [15, 12, 9, 6]], dtype=int32) **1D array sum** >>> jnp.einsum("i->", x) # requires explicit form Array(6, dtype=int32) >>> jnp.einsum(x, (0,), ()) # explicit form via indices Array(6, dtype=int32) >>> jnp.sum(x) Array(6, dtype=int32) **Sum along an axis** >>> jnp.einsum("...j->...", M) # requires explicit form Array([ 6, 22, 38, 54], dtype=int32) >>> jnp.einsum(M, (..., 0), (...,)) # explicit form via indices Array([ 6, 22, 38, 54], dtype=int32) >>> M.sum(-1) Array([ 6, 22, 38, 54], dtype=int32) **Matrix transpose** >>> y = jnp.array([[1, 2, 3], ... [4, 5, 6]]) >>> jnp.einsum("ij->ji", y) # explicit form Array([[1, 4], [2, 5], [3, 6]], dtype=int32) >>> jnp.einsum("ji", y) # implicit form Array([[1, 4], [2, 5], [3, 6]], dtype=int32) >>> jnp.einsum(y, (1, 0)) # implicit form via indices Array([[1, 4], [2, 5], [3, 6]], dtype=int32) >>> jnp.einsum(y, (0, 1), (1, 0)) # explicit form via indices Array([[1, 4], [2, 5], [3, 6]], dtype=int32) >>> jnp.transpose(y) Array([[1, 4], [2, 5], [3, 6]], dtype=int32) **Matrix diagonal** >>> jnp.einsum("ii->i", M) Array([ 0, 5, 10, 15], dtype=int32) >>> jnp.diagonal(M) Array([ 0, 5, 10, 15], dtype=int32) **Matrix trace** >>> jnp.einsum("ii", M) Array(30, dtype=int32) >>> jnp.trace(M) Array(30, dtype=int32) **Tensor products** >>> x = jnp.arange(30).reshape(2, 3, 5) >>> y = jnp.arange(60).reshape(3, 4, 5) >>> jnp.einsum('ijk,jlk->il', x, y) # explicit form Array([[ 3340, 3865, 4390, 4915], [ 8290, 9940, 11590, 13240]], dtype=int32) >>> jnp.tensordot(x, y, axes=[(1, 2), (0, 2)]) Array([[ 3340, 3865, 4390, 4915], [ 8290, 9940, 11590, 13240]], dtype=int32) >>> jnp.einsum('ijk,jlk', x, y) # implicit form Array([[ 3340, 3865, 4390, 4915], [ 8290, 9940, 11590, 13240]], dtype=int32) >>> jnp.einsum(x, (0, 1, 2), y, (1, 3, 2), (0, 3)) # explicit form via indices Array([[ 3340, 3865, 4390, 4915], [ 8290, 9940, 11590, 13240]], dtype=int32) >>> jnp.einsum(x, (0, 1, 2), y, (1, 3, 2)) # implicit form via indices Array([[ 3340, 3865, 4390, 4915], [ 8290, 9940, 11590, 13240]], dtype=int32) **Chained dot products** >>> w = jnp.arange(5, 9).reshape(2, 2) >>> x = jnp.arange(6).reshape(2, 3) >>> y = jnp.arange(-2, 4).reshape(3, 2) >>> z = jnp.array([[2, 4, 6], [3, 5, 7]]) >>> jnp.einsum('ij,jk,kl,lm->im', w, x, y, z) Array([[ 481, 831, 1181], [ 651, 1125, 1599]], dtype=int32) >>> jnp.einsum(w, (0, 1), x, (1, 2), y, (2, 3), z, (3, 4)) # implicit, via indices Array([[ 481, 831, 1181], [ 651, 1125, 1599]], dtype=int32) >>> w @ x @ y @ z # direct chain of matmuls Array([[ 481, 831, 1181], [ 651, 1125, 1599]], dtype=int32) >>> jnp.linalg.multi_dot([w, x, y, z]) Array([[ 481, 831, 1181], [ 651, 1125, 1599]], dtype=int32) .. _opt_einsum: https://github.com/dgasmith/opt_einsum Nz2The 'out' argument to jnp.einsum is not supported.rTrFch|]Q}t|ttj|D]%}t j|t |&RSrj)rFrAr}r?rrrQ)r*rrs rK zeinsum..sl 2s(;(;x|| 4#7#:#: 1ggrL) einsum_calluse_blasrc3BK|]^}}}}|t||fVdSr`) frozenset)r*rrrrs rKr,zeinsum..s7LL 1a!9Q<<+LLLLLLrL)rrrr^)ror)r)rrFrAr opt_einsum contract_pathnextr_poly_einsum_handlersr_default_poly_einsum_handlerrGr_einsumr named_call) subscriptsrrrrrrspec path_typenon_constant_dim_typesrty contractionsrs rKrrsar $8 $ $(_ R S SS"8A;44 >!$$#t++ii(eBSBSYa)  P,MM d)** + +B)--b2NOOM(= tdYHHH(LLL|LLLLL, w|D A A A&  ^F . . .F , &  6 66rLctjdddgfdD}dt|Dtj|i|\}}fd|D}||fS)Ndummyr?rPcg|]A}t|dr-td|jD|jn|BS)rPc3JK|]}t|tur|ndVdS)N)rQr^rs rKr,z:_default_poly_einsum_handler...s4EEd1ggnn!EEEEEErL)rrGr?rP)r*rMrs rKr2z0_default_poly_einsum_handler..sd > > >/07##+UU5EEQWEEEEEqw O O O)* > > >rLc4i|]\}}t||Srjrfrs rKrz0_default_poly_einsum_handler..s$ 5 5 5$!QRUUA 5 5 5rLcFg|]}t|Srjr)r*rmappingrs rKr2z0_default_poly_einsum_handler..s(EEEAx1/EEErL) collections namedtuplerrr)rrdummies out_dummiesrcontract_operandsrrs` @@rKrrs  7G*< = =% > > > >4< > > >' 5 5)G"4"4 5 5 5'(6J6JJ+|EEEEEEEE L ((rL)rr"bool | str | list[tuple[int, ...]]!tuple[list[tuple[int, ...]], Any]cdSr`rjrrrs rK einsum_pathrs ),rLcdSr`rj)rrJrrs rKrrs ),rLautoc^|durd}n|durt}tj|g|Rd|iS)aEvaluates the optimal contraction path without evaluating the einsum. JAX implementation of :func:`numpy.einsum_path`. This function calls into the opt_einsum_ package, and makes use of its optimization routines. Args: subscripts: string containing axes names separated by commas. *operands: sequence of one or more arrays corresponding to the subscripts. optimize: specify how to optimize the order of computation. In JAX this defaults to ``"auto"``. Other options are ``True`` (same as ``"optimize"``), ``False`` (unoptimized), or any string supported by ``opt_einsum``, which includes ``"optimize"``,, ``"greedy"``, ``"eager"``, and others. Returns: A tuple containing the path that may be passed to :func:`~jax.numpy.einsum`, and a printable object representing this optimal path. Examples: >>> key1, key2, key3 = jax.random.split(jax.random.key(0), 3) >>> x = jax.random.randint(key1, minval=-5, maxval=5, shape=(2, 3)) >>> y = jax.random.randint(key2, minval=-5, maxval=5, shape=(3, 100)) >>> z = jax.random.randint(key3, minval=-5, maxval=5, shape=(100, 5)) >>> path, path_info = jnp.einsum_path("ij,jk,kl", x, y, z, optimize="optimal") >>> print(path) [(1, 2), (0, 1)] >>> print(path_info) Complete contraction: ij,jk,kl->il Naive scaling: 4 Optimized scaling: 3 Naive FLOP count: 9.000e+3 Optimized FLOP count: 3.060e+3 Theoretical speedup: 2.941e+0 Largest intermediate: 1.500e+1 elements -------------------------------------------------------------------------------- scaling BLAS current remaining -------------------------------------------------------------------------------- 3 GEMM kl,jk->lj ij,lj->il 3 GEMM lj,ij->il il->il Use the computed path in :func:`~jax.numpy.einsum`: >>> jnp.einsum("ij,jk,kl", x, y, z, optimize=path) Array([[-539, 216, 95, 592, 209], [ 527, 76, 285, -436, -529]], dtype=int32) .. _opt_einsum: https://github.com/dgasmith/opt_einsum TrFr)rrrrs rKrr sLhHH5}}H  !* Kx K K K( K KKrLc|tt|Sr`) translaterA maketransdictfromkeys)rcharss rK _removecharsrCs, S]]4==#7#788 9 99rLrr5Sequence[tuple[tuple[int, ...], frozenset[str], str]]c  !"#$%&'()tjdttt|}tj|ddi\}nd}fd))fd})fd}d}|D]\} } } t | } | d \} }| d }t| d krd| | d }|\%tj %fd | D}||%|\}%||%|\}%n~t| dkrct|j | \ &|\#(| #t&(\ #|&(t #\&(tj #"tj ('"'fd| D}| #|\ #"'fd| D}|&(|\&(| #"|(z\ #|&('|#z\&(t#t(z$$fd| D} t#t(z!!fd|D}t#(fd|D\}}tjjs>t% #&(fd| Ds Jd j d#d&j d(d|}t#(fd| D\}}|d| z}t)#|}t)(|}||z|z%%|kr||f||ff}|& ||}n(||z|z%||f||ff}| &||}nt*t%t|cxkr tt%ksnJt%t|ksJ%|kr0t-%fd|D}t/j||}||t5j|d |S)NrrtTFctj||jkr|}t j|t jd|j|jtkr tj n tj |SNr) rrrPrrreducer}rrr bitwise_or)rMrJrs rKrz_einsum..sumUsr !344?? (() * *a :a!QW--!"E!1!1cggs~t M MMrLcf|r*fd|D}||}t||fS)Nc:g|]}|Srjrr*rnamess rKr2z0_einsum..sum_uniques..]s% 4 4 4Dekk$ 4 4 4rL)r)operandruniquesrJrs ` rK sum_uniquesz_einsum..sum_uniques[sO+ 4 4 4 4G 4 4 4dGT""g5'**e E>rLc|D]\}|dkrfdt|D}tjt jd|j|}tj||t|}|vr#||}| d}||dd}| d|dz }||fS)Nrc&g|] \}}|k |Srjrj)r*rDrrs rKr2z0_einsum..sum_repeats..es"<<r) rrr_deltar}rPr?rrqrreplace) rrr keep_namesr]rJrrrs @rK sum_repeatsz_einsum..sum_repeatsbs||~~ 5 5 e <<<+>?? z ! !C&&'--b))%%Ccrc++'--b%!)44% E>rLcRtjfdtt|jD}t |t tj\}}tj |d fd|DfS)Ncvg|]5\}}j|d p|dkp|d6S)rrr))r*rDrr|r other_shapes rKr2z:_einsum..filter_singleton_dims..rsg A A A17=#Q'' ' K17 KbbQ6K6K A A ArLr>c3(K|] }|V dSr`rj)r*rDrs rKr,z9_einsum..filter_singleton_dims..us'3P3PE!H3P3P3P3P3P3PrL) rrrrfindr9rHrrErrjoin)rrr other_nameskeep sqez_axes keep_axesr|s``` @rKfilter_singleton_dimsz&_einsum..filter_singleton_dimsps B A A A A A A!#k&6">">?? A A AD)$U7<5H5H0I0IJJIy ;w * *BGG3P3P3P3Pi3P3P3P,P,P PPrLz->,rrc,g|]}|dk|Srrj)r*rrs rKr2z_einsum..s'HHH$fTla6G6G6G6G6GrLrcDg|]}|dk|dk|Srrjr*r lhs_counts rhs_countss rKr2z_einsum..DIIId"4(A--*T2Ba2G2G2G2G2GrLcDg|]}|dk|dk|Srrjrs rKr2z_einsum..rrLcg|]}|v| Srjrj)r*rMlhs_or_rhs_namess rKr2z_einsum..s$OOO>N9N9N!9N9N9NrLcg|]}|v| Srjrj)r*rMlhs_and_rhs_namess rKr2z_einsum..s$GGG15F0F0FQ0F0F0FrLc3lK|].}||fV/dSr`)rr*r lhs_names rhs_namess rKr,z_einsum..sT$:$:()&/^^A%6%6 q8I8I$J$:$:$:$:$:$:rLc3K|]N}|voE|voAj|j|kVOdSr`)r?r)r*rlhsr rhsr s rKr,z_einsum..s0&0&   Mdi/ M )//$''(CIiood6K6K,LL0&0&0&0&0&0&rLz-Incompatible reduction dimensions: lhs.shape=z lhs_names=z rhs.shape=z rhs_names=r>c3lK|].}||fV/dSr`rr s rKr,z_einsum..sT"="=&'$-??1#5#5yq7I7I"J"="="="="="=rL)rc3BK|]}|VdSr`rrs rKr,z_einsum..s/>>5;;t$$>>>>>>rL)rrrHrrSrr!rrpoprCounterr?rr5rrrrrrrrGrrr8rr )*rrrrrrxrrroperand_indicescontracted_names_seteinstrcontracted_names input_str result_names input_namesrr lhs_uniques rhs_uniques batch_names lhs_batch rhs_batchbatch_names_strlhs_contrhs_cont deleted_namesremaining_lhs_namesremaining_rhs_namesrvrarrr rr rrrrr rs* ` @@@@@@@@@@@rKrrGs #$:HEEE #gx(( ) )(#/5/A8/hcg/h/h,,,MMMMM      QQQ8Daa3o+V233$ll400I|//#&&K ?q   _Q/00gfe"5))fIHHH"2HHHg"{7E7;;ngu#{7E6<HHnguu _   " "X\?33hc3(i-,S)U3ZZ-688nc9,,S)U3ZZ-688nc9&y11j&y11jIIIII&6IIIk"{3 ;??nc9IIIII&6IIIk"{3 ;??nc9#{3 :#/)#;==nc9"{3 :#/)#;==nc9Y#i..8OOOO%5OOOi..3y>>9GGGG GGGk#$:$:$:$:$:-8$:$:$:::i  " (:C0&0&0&0&0&0&0&%0&0&0&-&-&:: 9y 9 9-6 9 9y 9 9-6 9 9 ::: ,,o!"="="="="=+;"="="===h%0@(A(AAm(MBB(MBB  336IIe ,  &1Iy3IJ,sC):I6LNNN "558KK&1Iy3IJ,sC):I6LNNN  u::\** = = = =c#e**oo = = = = = = u::\** * * * *  >>>>>>> > >d gt,,g OOG  +HQK9OQa b bbrL DType | Nonectjd||t|dkst|dkr't||}t||}||zSt ||d||S)a>Compute the inner product of two arrays. JAX implementation of :func:`numpy.inner`. Unlike :func:`jax.numpy.matmul` or :func:`jax.numpy.dot`, this always performs a contraction along the last dimension of each input. Args: a: array of shape ``(..., N)`` b: array of shape ``(..., N)`` precision: either ``None`` (default), which means the default precision for the backend, a :class:`~jax.lax.Precision` enum value (``Precision.DEFAULT``, ``Precision.HIGH`` or ``Precision.HIGHEST``) or a tuple of two such values indicating precision of ``a`` and ``b``. preferred_element_type: either ``None`` (default), which means the default accumulation type for the input types, or a datatype, indicating to accumulate results to and return a result with that datatype. Returns: array of shape ``(*a.shape[:-1], *b.shape[:-1])`` containing the batched vector product of the inputs. See also: - :func:`jax.numpy.vecdot`: conjugate multiplication along a specified axis. - :func:`jax.numpy.tensordot`: general tensor multiplication. - :func:`jax.numpy.matmul`: general batched matrix & vector multiplication. Examples: For 1D inputs, this implements standard (non-conjugate) vector multiplication: >>> a = jnp.array([1j, 3j, 4j]) >>> b = jnp.array([4., 2., 5.]) >>> jnp.inner(a, b) Array(0.+30.j, dtype=complex64) For multi-dimensional inputs, batch dimensions are stacked rather than broadcast: >>> a = jnp.ones((2, 3)) >>> b = jnp.ones((5, 3)) >>> jnp.inner(a, b).shape (2, 5) rrrn)rrr)r*rrErSrrs rKrrs^w1%%% !WW\\T!WW\\/000A/000A q5L 1aY*@ B B BBrL)rc|tdtjd||tj||\}}t |dddft |dddfzS)Nz1The 'out' argument to jnp.outer is not supported.outer)rr*rrr)rrrs rKr*r*st _ Q R RRw1%%% Q " "$!Q q!!!T' U1XXdAAAg. ..rL)axisaaxisbaxiscrbr+r,r-ctjd||||}|}|}t||d}t||d}|jddvs|jddvrt d|jddkr4|jddkr#|d|dz|d|dzz S|d}|d}|jddkr|d nt |}|d} |d} |jddkr|d nt | } t || z|| zz || z|| zz || z|| zz g} t| d |S) Ncrossr)rrz1Dimension must be either 2 or 3 for cross productr).r).rr).rr)r*rrr?rrr) rrr+r,r-rba0rTrUb0b1b2rs rKr/r/s} w1%%%  E E Eq%!q%!WR[!'"+V";"; H I IIWR[A!'"+** V9qy 1V9qy#8 88y"y"GBK1$$qyy*R.."y"y"GBK1$$qyy*R.." R"WrBw R"r' 127R"W3D EFF! !Q  rLc Btjd||tj||\}}t|t|kr;t |t t|t|z }nZt|t|kr:t |t t|t|z }t |t ddt|zd}t |t ddt|zd}t tjt|t|}ttj |||S)Nkronrrr) r*rrrErrrGr}rr?r=rr1)rr a_reshaped b_reshapedrds rKr5r5;s:vq!$$$ Q " "$!Q !WWtAwwAuT!WWtAww.//00AA AwwaAuT!WWtAww.//00A1eAq477{A6677*1eAq477{A6677*BKa%((3344) Z00) < <>> x = jnp.array([[1, 0, 2], ... [0, 3, 0]]) >>> jnp.argwhere(x) Array([[0, 0], [0, 2], [1, 1]], dtype=int32) Equivalent computation using :func:`jax.numpy.column_stack` and :func:`jax.numpy.nonzero`: >>> jnp.column_stack(jnp.nonzero(x)) Array([[0, 0], [0, 2], [1, 1]], dtype=int32) Special case for zero-dimensional (i.e. scalar) inputs: >>> jnp.argwhere(1) Array([], shape=(1, 0), dtype=int32) >>> jnp.argwhere(0) Array([], shape=(0, 0), dtype=int32) rYrN)rrrdrrEr=r?)rrrZrs rKargwherer=asv VGJqMMTTTUU V V& !WW\\ "1":  fl1oq 1 11  Qa 1 11rLrctjd||tdtt ||dnt j|t|S)Nrlz2The 'out' argument to jnp.argmax is not supported.r)r*rr_argmaxrSrrrNrrbrrs rKrlrlgx###_ R S SS T\TTx~d7K7Kx.. * * **rLrcj|;ttt|}t|}d}n|g}|j|dkrt dt j|t||jtj t}|rt||n|S)Nrz*attempt to get argmax of an empty sequence) rHrrErr?rrrlrOrrrrrrbrrrs rKr@r@ \ d1gg  D aA DD 6DWT]a A B BB :a+D!&996;TUY;Z;Z [ [&&. :VT " " "F:rLctjd||tdtt ||dnt j|t|S)NrLz2The 'out' argument to jnp.argmin is not supported.r?)r*rr_argminrSrrrNrAs rKrLrLrBrLcj|;ttt|}t|}d}n|g}|j|dkrt dt j|t||jtj t}|rt||n|S)Nrz*attempt to get argmin of an empty sequence) rHrrErr?rrrLrOrrrrrDs rKrGrGrErLzTWarning: jax.numpy.arg{} returns -1 for all-NaN slices and does not raise an error. )rWrc|tdt||dntj|t |S)Nz5The 'out' argument to jnp.nanargmax is not supported.r?)r _nanargmaxrrrNrAs rK nanargmaxrKI _ U V VV At|tt1E1EPTU]P^P^ _ _ __rLcZtjd|tt|tst |||St j|}t|t |}t |||}ttj |||d|S)NrKrr) r*rrTr[rrlr)rrinfr(rrrbrnan_maskrs rKrJrJs{A&&& F1IIw ' '3 !$ 2 2 22 \!__( HsdA!qth///# z~hTHEEEr3 O OOrLc|tdt||dntj|t |S)Nz5The 'out' argument to jnp.nanargmin is not supported.r?)r _nanargminrrrNrAs rK nanargminrSrLrLcXtjd|tt|tst |||St j|}t|t|}t |||}ttj |||d|S)NrSrr) r*rrTr[rrLr)rrrNr(rrOs rKrRrRs{A&&& F1IIw ' '3 !$ 2 2 22 \!__( Hc1!qth///# z~hTHEEEr3 O OOrL)rbkindrstable descending)rUrrVrWrUrVrWcDtjd||td|td|t|}d}nt |}t ||j}tj|||}|rtj ||gn|S)aReturn a sorted copy of an array. JAX implementation of :func:`numpy.sort`. Args: a: array to sort axis: integer axis along which to sort. Defaults to ``-1``, i.e. the last axis. If ``None``, then ``a`` is flattened before being sorted. stable: boolean specifying whether a stable sort should be used. Default=True. descending: boolean specifying whether to sort in descending order. Default=False. kind: deprecated; instead specify sort algorithm using stable=True or stable=False. order: not supported by JAX Returns: Sorted array of shape ``a.shape`` (if ``axis`` is an integer) or of shape ``(a.size,)`` (if ``axis`` is None). Examples: Simple 1-dimensional sort >>> x = jnp.array([1, 3, 5, 4, 2, 1]) >>> jnp.sort(x) Array([1, 1, 2, 3, 4, 5], dtype=int32) Sort along the last axis of an array: >>> x = jnp.array([[2, 1, 3], ... [4, 3, 6]]) >>> jnp.sort(x, axis=1) Array([[1, 2, 3], [3, 4, 6]], dtype=int32) See also: - :func:`jax.numpy.argsort`: return indices of sorted values. - :func:`jax.numpy.lexsort`: lexicographical sort of multiple arrays. - :func:`jax.lax.sort`: lower-level function wrapping XLA's Sort operator. r]Nzd'kind' argument to sort is not supported. Use stable=True or stable=False to specify sort stability.z*'order' argument to sort is not supported.rr' is_stabler) r*rrxrrSrOrErr]rm) rrbrUrrVrWrr'rs rKr]r]s^vq!!!  N O OO  @ A AA \ ((C DD !**C sx00) 8C9 ? ? ?&4> JYK 0 0 0 0FJrLctjd|tjt |d}tj|t j|jS)N sort_complexrr&) r*rrr]rSrrto_complex_dtyperP)rs rKr\r\BsQ~q))) hwqzzQ'''! !!V%.Ns(33AWQZZ333333rLrz-need sequence of keys with len > 0 in lexsortc,h|]}t|Srjr))r*rs rKrzlexsort..Qs + + +%** + + +rLrz"all keys need to be the same shapernr)r'num_keys)rGr*rrrxrrErrrrrOr?rrrr])r^rb key_tuple key_arraysuse_64bit_indexrs rKraraIsbDkk)y-9----3333333*__ C D DD + + + + +,,q00 9 : :: *Q-A &3D99 : : :: D$z!}"5"5 6 6$qM'-':/ @eeD% ST BVBVX\ ] ]$ +Jttt$+d++tc*oo V V VWY ZZrLctjd|t|}|td|td|t |}d}nt|}t ||j}tj|j | p|j |dk}tj |rtnt|j |} |r0|r.tj||g}tj| |g} tj|| ||\} } |rtj| |gn| S) aReturn indices that sort an array. JAX implementation of :func:`numpy.argsort`. Args: a: array to sort axis: integer axis along which to sort. Defaults to ``-1``, i.e. the last axis. If ``None``, then ``a`` is flattened before being sorted. stable: boolean specifying whether a stable sort should be used. Default=True. descending: boolean specifying whether to sort in descending order. Default=False. kind: deprecated; instead specify sort algorithm using stable=True or stable=False. order: not supported by JAX Returns: Array of indices that sort an array. Returned array will be of shape ``a.shape`` (if ``axis`` is an integer) or of shape ``(a.size,)`` (if ``axis`` is None). Examples: Simple 1-dimensional sort >>> x = jnp.array([1, 3, 5, 4, 2, 1]) >>> indices = jnp.argsort(x) >>> indices Array([0, 5, 4, 1, 3, 2], dtype=int32) >>> x[indices] Array([1, 1, 2, 3, 4, 5], dtype=int32) Sort along the last axis of an array: >>> x = jnp.array([[2, 1, 3], ... [6, 4, 3]]) >>> indices = jnp.argsort(x, axis=1) >>> indices Array([[1, 0, 2], [2, 1, 0]], dtype=int32) >>> jnp.take_along_axis(x, indices, axis=1) Array([[1, 2, 3], [3, 4, 6]], dtype=int32) See also: - :func:`jax.numpy.sort`: return sorted values directly. - :func:`jax.numpy.lexsort`: lexicographical sort of multiple arrays. - :func:`jax.lax.sort`: lower-level function wrapping XLA's Sort operator. r`Nzg'kind' argument to argsort is not supported. Use stable=True or stable=False to specify sort stability.z-'order' argument to argsort is not supported.rrdrrY)r*rrSrxrrOrErrr?rrrrrmrH) rrbrUrrVrWrr'rhrrrs rKr`r`[sSny!$$$ #  N O OO  C D DD \ **C DD !**C sx00),SYy-ABBBgciPYFZ_fFg/ @eeD#)Y W W$1F1 '#9+ . . .C 74YK 0 0 0DTY&QQQ*!W5? Li[ 1 1 1 1WLrLkthctjd|t|}t|jt jrtdt||j }t||j |}t||d}tj |jdr'tj|dz |dzd dz }n tj| |dzd }tj||j d|z dz d}tj||g|j dz }t|d|S)aReturns a partially-sorted copy of an array. JAX implementation of :func:`numpy.partition`. The JAX version differs from NumPy in the treatment of NaN entries: NaNs which have the negative bit set are sorted to the beginning of the array. Args: a: array to be partitioned. kth: static integer index about which to partition the array. axis: static integer axis along which to partition the array; default is -1. Returns: A copy of ``a`` partitioned at the ``kth`` value along ``axis``. The entries before ``kth`` are values smaller than ``take(a, kth, axis)``, and entries after ``kth`` are indices of values larger than ``take(a, kth, axis)`` Note: The JAX version requires the ``kth`` argument to be a static integer rather than a general array. This is implemented via two calls to :func:`jax.lax.top_k`. If you're only accessing the top or bottom k values of the output, it may be more efficient to call :func:`jax.lax.top_k` directly. See Also: - :func:`jax.numpy.sort`: full sort - :func:`jax.numpy.argpartition`: indirect partial sort - :func:`jax.lax.top_k`: directly find the top k entries - :func:`jax.lax.approx_max_k`: compute the approximate top k entries - :func:`jax.lax.approx_min_k`: compute the approximate bottom k entries Examples: >>> x = jnp.array([6, 8, 4, 3, 1, 9, 7, 5, 2, 3]) >>> kth = 4 >>> x_partitioned = jnp.partition(x, kth) >>> x_partitioned Array([1, 2, 3, 3, 4, 9, 8, 7, 6, 5], dtype=int32) The result is a partially-sorted copy of the input. All values before ``kth`` are of smaller than the pivot value, and all values after ``kth`` are larger than the pivot value: >>> smallest_values = x_partitioned[:kth] >>> pivot_value = x_partitioned[kth] >>> largest_values = x_partitioned[kth + 1:] >>> print(smallest_values, pivot_value, largest_values) [1 2 3 3] 4 [9 8 7 6 5] Notice that among ``smallest_values`` and ``largest_values``, the returned order is arbitrary and implementation-dependent. partitionz3jnp.partition for complex dtype is not implemented.runsigned integerrrr&)r*rrSrTrPr}rUrrOrEr?rrrrtop_kr)rrjrbrbottomtoprs rKrlrls7h{A&&& # 2-..U S T TT D#( + +$3 $00#dB# ^CI122*i#' C!G,,Q/ /! 3FFicAg&&q) )F #sy}s*Q.//2#  A>>># #r4  rLc8tjd|t|}t|jt jrtdt||j }t||j |}t||d}tj |jdr#tj|dz |dzd}ntj| |dzd}d}t!|j dz D]}t#j|}|t'|j |}tj||j d|z dz d}tj||g|j dz } t| d|S)aeReturns indices that partially sort an array. JAX implementation of :func:`numpy.argpartition`. The JAX version differs from NumPy in the treatment of NaN entries: NaNs which have the negative bit set are sorted to the beginning of the array. Args: a: array to be partitioned. kth: static integer index about which to partition the array. axis: static integer axis along which to partition the array; default is -1. Returns: Indices which partition ``a`` at the ``kth`` value along ``axis``. The entries before ``kth`` are indices of values smaller than ``take(a, kth, axis)``, and entries after ``kth`` are indices of values larger than ``take(a, kth, axis)`` Note: The JAX version requires the ``kth`` argument to be a static integer rather than a general array. This is implemented via two calls to :func:`jax.lax.top_k`. If you're only accessing the top or bottom k values of the output, it may be more efficient to call :func:`jax.lax.top_k` directly. See Also: - :func:`jax.numpy.partition`: direct partial sort - :func:`jax.numpy.argsort`: full indirect sort - :func:`jax.lax.top_k`: directly find the top k entries - :func:`jax.lax.approx_max_k`: compute the approximate top k entries - :func:`jax.lax.approx_min_k`: compute the approximate bottom k entries Examples: >>> x = jnp.array([6, 8, 4, 3, 1, 9, 7, 5, 2, 3]) >>> kth = 4 >>> idx = jnp.argpartition(x, kth) >>> idx Array([4, 8, 3, 9, 2, 0, 1, 5, 6, 7], dtype=int32) The result is a sequence of indices that partially sort the input. All indices before ``kth`` are of values smaller than the pivot value, and all indices after ``kth`` are of values larger than the pivot value: >>> x_partitioned = x[idx] >>> smallest_values = x_partitioned[:kth] >>> pivot_value = x_partitioned[kth] >>> largest_values = x_partitioned[kth + 1:] >>> print(smallest_values, pivot_value, largest_values) [1 2 3 3] 4 [6 8 9 7 5] Notice that among ``smallest_values`` and ``largest_values``, the returned order is arbitrary and implementation-dependent. rlz6jnp.argpartition for complex dtype is not implemented.rrmrcB|j|dSr)rr)rrDs rKrzargpartition..5sQT!W[[^^rLr&)r*rrSrTrPr}rUrrOrEr?rrrrrnrrrrNr) rrjrbr bottom_ind set_to_zerorproxytop_indrs rK argpartitionrws~j{A&&& # 2-..X V W WW D#( + +$3 $00#dB# ^CI122-S1W:sQw//2JJC4q))!,J,++ A  ((a(;''KK +d39ooz 2 2% IeSYr]S014 5 5a 8' W-AFFF# #r4  rLrrc tj|jtj|}t |dkrd}t |t t||tj||D]\}}t|j|tj }tj tj |tj tj |tj d}tj||f|}tj|||z |j||}|S)NrzA'shift' and 'axis' arguments to roll must be scalars or 1D arraysrnrh)rrxr?r}rrrrrrr) remainderrrrdynamic_slice_in_dim) rrrbb_shapernrMrD a_shape_ia_concats rK _roll_dynamicr~>s   bhtnn = ='\\Q MC S//,ug../$0022NNdaagaj111I1!RX>>BHQKK88 : :A1vq))H  9q=!'!*1MMMAA (rLr c .ttj||D]w\}}|j|dkr| |j|z}t jt j|||j||t j|d||g|}x|S)Nrrhr&)rr}rkr?rrr)rrrbrlrrDs rK _roll_staticrNsB'e445&&eb!wr{a qwr{A )!Q "EEE)!Q;;;="$ & & &AA (rLArrayLike | Sequence[int]ctjd|t||;t|djSt|}tfd|D} t|}t||S#t$r!tt||cYSwxYw)Nrrc3BK|]}t|jVdSr`rN)r*rlrs rKr,zroll..as0??B!"ch//??????rL) r*rrSrrr=r?rrGrrxr~)rrrbrs @rKrrYsvq!!! # \  UA & & . .sy 9 99 T " "$ ????$??? ? ?$*  & &E UD ) )) 444 gennd 3 33334sB..(CC)rbrcJtjd|tjtj|d}t |}t||}| |cxkr|ksntd|d| d||dkr||z }||kr|dz}t|||S)aQRoll the specified axis to a given position. JAX implementation of :func:`numpy.rollaxis`. This function exists for compatibility with NumPy, but in most cases the newer :func:`jax.numpy.moveaxis` instead, because the meaning of its arguments is more intuitive. Args: a: input array. axis: index of the axis to roll forward. start: index toward which the axis will be rolled (default = 0). After normalizing negative axes, if ``start <= axis``, the axis is rolled to the ``start`` index; if ``start > axis``, the axis is rolled until the position before ``start``. Returns: Copy of ``a`` with rolled axis. Notes: Unlike :func:`numpy.rollaxis`, :func:`jax.numpy.rollaxis` will return a copy rather than a view of the input array. However, under JIT, the compiler will optimize away such copies when possible, so this doesn't have performance impacts in practice. See also: - :func:`jax.numpy.moveaxis`: newer API with clearer semantics than ``rollaxis``; this should be preferred to ``rollaxis`` in most cases. - :func:`jax.numpy.swapaxes`: swap two axes. - :func:`jax.numpy.transpose`: general permutation of axes. Examples: >>> a = jnp.ones((2, 3, 4, 5)) Roll axis 2 to the start of the array: >>> jnp.rollaxis(a, 2).shape (4, 2, 3, 5) Roll axis 1 to the end of the array: >>> jnp.rollaxis(a, 1, a.ndim).shape (2, 4, 5, 3) Equivalent of these two with :func:`~jax.numpy.moveaxis` >>> jnp.moveaxis(a, 2, 0).shape (4, 2, 3, 5) >>> jnp.moveaxis(a, 1, -1).shape (2, 4, 5, 3) rollaxisz"'start' argument of jnp.rollaxis()zstart=z must satisfy z <=start<=rr) r*rrrrrrErOrr)rrbrrzs rKrrjshz1%%%  8\ ] ]% 77& D& ) )$ 'U $ $ $ $f $ $ $ $ HHHvgHHHH I II QYY VOE T\\ QJE !T5 ! !!rL)rbbitorderbigrc tjd|t|}t|jt s)t|jt std|dvrtdtj |t|d d}tdd}|d kr |ddd }|t|}d}t||d }|jd dz}|r>tj|t%jd|jd z d gzdd|z dfgz}||jdd |jd dzdfz}t-|t/t1|jd z }||zd  d}t||d S) Npackbitsz7Expected an input array of integer or boolean data typelittler('order' must be either 'little' or 'big'ruint8rrnrrrr)r*rrSrTrPrrrxrrgtrrrrrr?r"r}rrEr=rrGrr)rrbrrbitsrypackeds rKrrs z1%%% # SY ( (OJsy%,H,HO M N NN &&& ? @ @@ sJq!$$%%,,W55#  ! ! !$  ":D \ **C DdB#ima)J '#rx{{8a>> 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)rrrZ)_takerr)rrrbrrrrrZs rKrrsAd q'4<44X^D5I5I3NGY$ & & &&rL)rbrrrrZc "|tdtjd||t|}t|}|t |}d}nt |t |}||dkr5tjj } t|dk||j |z|}n|dkrtd|dkr@tj |t||j |}tjj} n+|dkrtjj} nt#d |d t%t|} t't|} | |dkr|jdkrt+d |S|jdkr?| d|t'|j z| |d zdz} t-|d| Sd | |<tjt1t't3|t't3|| zt%|j | zd z z|f|f} tj||d| t1| | |||S)Nz0The 'out' argument to jnp.take is not supported.rrfillrz.The 'raise' mode to jnp.take is not supported.rrzInvalid mode 'z ' for np.takez4Cannot do a non-empty jnp.take() from an empty axis.rr) offset_dimscollapsed_slice_dimsstart_index_mapr;)rv slice_sizesrrrrZ)rr*rrSrrOrErGatherScatterMode FILL_OR_DROPrr?r)rrPROMISE_IN_BOUNDSCLIPrrrHr IndexErrorr?GatherDimensionNumbersrGrgather)rrrbrrrrrZaxis_idx gather_mode index_dimsrrddnumss rKrr@s _ P Q QQvq'*** ajj! G  ' \ aAHH!$Q00H \TV^^'4KGaK178+>""*U1XX+a|q M N NN H \QYhY'$w}*=*==X\]]+,I Q + + +++h $ 5?? 5J&AG z(AA(E F FGGHII#K  ! ! !% Awy)U %k 2 2$^'9j R R RRrLctt|tjr|St j|rt ||}n4tjt j |t|}t|ttj fr|dkrtj ||n|Stj|dktj |||S)zCNormalizes an index value in the range [-N, N) to the range [0, N).r)rTr[r}unsignedintegerrrrrrdimension_as_valuerFr^rrrq)rr8 axis_size_vals rK_normalize_indexrwsu r122 L )$$<ui00MM,T-DY-O-O-3E]]<!> F FFrL)rbrrZ"str | lax.GatherScatterMode | Nonectjd||t|}tj|}t |}tj|tstd||Mt|dkr$d}t| || }d}|j } | t|kr7d}t| t||j t|| fd} td |jD} t | rtnt }t#j||}|j} | |jd} t#j|| }| dkrt)||jSfd t+|D}t-t/j||d z}g}g}g}g}g}d}t3| D]}|kr}t5|| }|t#j|||d|||||dz }t;j||dr1|||| |t;j| |drj|t)|| |d|||||dz }Wt#j|||}|||d|||||dz }t#j || }t#j!t-|t-|t-|}t#j"|||t-||dn||S)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 Nrz=take_along_axis indices must be 1D if axis=None, got shape {}rzBindices and arr must have the same number of dimensions; {} vs. {}cJt|}||<t|Sr`)rHrG)rrlstaxis_ints rKrz take_along_axis..replaces# s))CCM ::rLc3LK|]}tj| p|dkV dSrdNrrrs rKr,z"take_along_axis..s9WW!D0333EqW~WWWWWWrLcPg|]"\}}|kstj|d |#Sr)rr)r*rDrprs rKr2z#take_along_axis..s5kkkfaX TMbcfhiMjMj  rLrrnr&rr)rrZ)#r*rrSrrPr?rTrrxrErr rrOr6rrrrrxrrrGr}rrrr8r=rrrrrr)rrrbrrZr index_dtype idx_shapernrrrhr8r+rdrgather_index_shaperrrrrrrDrgather_indices_arrrrs @rKrrs^(#w777 cll! W%%+Gnn)  ; 0 0& %"%% & && \ G}} Kc szz),, - --  A D $ T']] NC SZZW qv66 7 77 d + +( WWqwWWWWW/9eeE::+  $Wk : :'gh)gagq!!)"9i88)!^^ AG $ $$kkkk ) 4 4kkk*RXi00<==D.++/! ;;  aH}} )44gCK1CDDEEEQ!!!$$$1faa y|Q / / 1&&&& y|Q / / E"4KHHHIIIQ!!!$$$1faa  !+/A1 E EdD!!!Q!!!$$$1faa~CCC $k""344/** , , ,% A)5% 2D2D#'<Tj R R RRrLrpct|ttjfo!t|ttjf Sr`)rFr^r}rrNrrps rK_is_integer_indexr+s2 C#rz* + + UJsT28DT4U4U0UUrLct|to:|j|jcxuodunco$t|jt o |jdkS)Nr)rFrrr@rr^rs rK_is_simple_reverse_slicer.s^ S%  7 )sx ' ' ' '4 ' ' ' ' 7 SXs # # 7(+B8rLc|dkrdSt|r| |cxko|kncS tj|t|}}n#YdSxYw|dkr#tj|tjr|dvSdS)NrFrj)Npromise_inboundsr)rr}r?r[rTr)rprrr?rPs rK!_is_valid_integer_index_for_slicer3s QYY 5s 5C    $    8C==&++5EE 55 b[[R]5"*55[ 5 55 s #AAct|toa|jdupt|joD|jdupt|jo'|jdupt|jo |jdkSNr)rFrrrr@rrs rK_is_contiguous_slicerAs S%  P 9  < 1#) < < P 8t  :0:: P 8t  N 1#( ; ; MA QrL Array | NonecttrnftdjDsdSt jkrdSt dDrdSt dDrdSt dDrtjdtDfdttjD}dtD}ttotj j  }t fd |D}|r|s|rdSt t |zt |zt krdSrOtjttfd tD|z}|s|sSjt z t!dfzz g}g}t#jD]\} } t| t r]| | \} } } | d ksJ|| |t)d | | z wt+jt/| t*jsJt+j| d ksJ|| |d td|Dr>d|D}dt||D}tj||n8t |d krt3j|}tj|||r"tjt|S)Nc3@K|]}t|tVdSr`rSrs rKr,z4_attempt_rewriting_take_via_slice..Ks, 3 3AZ3   3 3 3 3 3 3rLc3K|]}|duV dSr`rjrs rKr,z4_attempt_rewriting_take_via_slice..Os&  qd      rLc3K|]D}t|t|j|j|jfD]}t j|VEdSr`)rFrrr@rrrr*rDrs rKr,z4_attempt_rewriting_take_via_slice..Rst / / Au-- /Wafaf- / /   c " " / / / / / / /rLc3(K|] }|tuVdSr`Ellipsisrs rKr,z4_attempt_rewriting_take_via_slice..Ws&$$1h$$$$$$rLrc6h|]\}}t||Srj)rr*rDinds rKrz4_attempt_rewriting_take_via_slice..[s*QQQvq#3KC3P3PQQQQrLcBh|]\}\}}t|||Srj)r)r*rDrrrs rKrz4_attempt_rewriting_take_via_slice..\sHHHH~q+35c4FFHHHHrLc6h|]\}}t||Srj)rrs rKrz4_attempt_rewriting_take_via_slice..^s*SSSVQ9Mc9R9RSqSSSrLc3K|]<}|j|dj|dfkV=dSr)rr?)r*rDrrps rKr,z4_attempt_rewriting_take_via_slice..fs_77 q6>>#)A,77Asy|Q;OO777777rLc3HK|]\}}|vrtdn|VdSr`r[)r*rDr simple_revss rKr,z4_attempt_rewriting_take_via_slice..psO..As !K//d S......rLrrrjc3dK|]+}t|ttjfo|dkV,dSr)rFr^r}rrs rKr,z4_attempt_rewriting_take_via_slice..s<LLARZ( ) ) 4a1fLLLLLLrLc,g|]}t|Srj)r^rs rKr2z5_attempt_rewriting_take_via_slice..s777AQ777rLcg|] \}}||z Srjrj)r*rDrs rKr2z5_attempt_rewriting_take_via_slice..s OOO41aQOOOrL) start_indices limit_indices)rr)rFrGrr?rrEr6_canonicalize_tuple_indexrrr ris_single_device_shardingrrrmrr7rr8rr}rTr[rr*r dynamic_slicer)rrpr int_indicescontiguous_slices is_shardedhas_partial_slicesrrrrrr@rint_start_indicesint_limit_indicesrs``` @rK!_attempt_rewriting_take_via_slicerGs#u%%1C6# 3 3 3 3 3 3 3 4XX 4  C      4 / / / / /// 4$$$$$$$7 #CH# 6 6 6CQQ3QQQ+HHHH3sCI3F3F)G)GHHH+SSy~~SSS 3 **E6s|DDD 77777$577777[$6 4K(((3/@+A+AASXXMM 4% '#u[)) * *C ....'nn... . .C$ + J#(SXX %++ //#')-!+C++  ic4#u ++d++eT4 QYYYY5!!!Qu --.... ]6#;; 3 3333 Xc]]b 3LLmLLLLL C77777OO3/@++N+NOOO ) ,.s,))As  ))))))rLz.JAX does not support string indexing; got idx=N)#_eliminate_deprecated_list_indexingr6rx_expand_bool_indicesrrrrrFrrr@rrG)rpr?r)rdynamicstaticrDrMs rKrrs ,C00#))S)))))I GGG H HH S%((# %%/&' FS[[ ' 6CKK &daH}}fQii Au  7AFAF+fQiigajj %-- ((rLc Ng}t||D]~\}}|||t|tr7|t |d|d|di||||S)z;Recombines indices that were split by _split_index_for_jit.Nrrr)rr8rFrGr unflatten)rrrrprrs rKrrs #*k**da} jjmmmm Au   jjqtQqT1Q4(()))) jjmmmm   3  rLcF|j ot|jtSr`)r?rTrPr)r's rK_intr s Z ;Jtz7;;;rLx_shapenormalize_indicesc &'(tt|}dt|D}|r_td|D}t t |D]}|dtd}d}g}d}t|rdt|D} dt| D} |rfd| D} t| \}}}ttj tj |dk}d} d} d} g}g}g}td Dotjj}|rt"nt$'g}g&g}g}g}g}t|D]\}}||r ||dks|s|dkrt'|}|dj}t|}t&(|'(fd |Dz }&|z &||||||| |z } | |z } ||vr| dz } |d t/j|}n#t2$rd}YnwxYwt5|t6t8frt;|rt/j| drt?d | d |rtA|| n|}tCj"|'}||t&f|| |d|| | dz } |1|d|| | dz } t5|tFrtd |j$|j%|j&fDs*d|j$d|j%d|j&d}t?|tO|| \}}}||t/j|drt/j|| sL|tCj"|'t&f|| |||| ntQ|'tQ|'tCj)'|zz} |dkr+|| tCj*| d} |d|| t&f|| &||| | dz } | dz } | dz } R|dtW|j,tZsJtW|j,t\s0d}t3|/|j,j0||t?d|d|t|dkrtj1d'}!nt|dkr'|d\}"}#tCj2|"|"j3f}!nEt&}$&dtCj4&fd|D|$}!tCj5t|tt |t|}%tm|t||||%|!|du|du| S)NcBg|]\}}t|t|Srj)rFrN)r*rrDs rKr2z$_index_to_gather..)s-$Y$Y$Y41aZPQSWEXEX$YQ$Y$Y$YrLc3K|]<}t|tr!tjt |n|V=dSr`)rFrNr}rr^rs rKr,z#_index_to_gather..+sFMMAZ4%8%8? #a&&!!!aMMMMMMrLrFc g|] \}}|||f Sr`rjrs rKr2z$_index_to_gather..Bs!GGGtq!QFrLc3K|]R\}\}}t|s't|tttjf>t |||fVSdSr`)rrFrr,r}rrS)r*rrDrs rKr,z#_index_to_gather..Cs|FF&QA !F"1x &CDDFqzz1aFFFFFFrLc3RK|]!\}}}t||||fV"dSr`)r)r*rrDrr s rKr,z#_index_to_gather..GsR77#Aq!*!WQZ88!Q?777777rLrc3LK|]}tj| p|dkV dSrrrs rKr,z#_index_to_gather..Vs9GG!D  # ##5qW~GGGGGGrLc3FK|]}tj|fVdSr`)rr)r*rr start_dims rKr,z#_index_to_gather..{sI4421kBBIN444444rLz index is out of bounds for axis z with size 0c34K|]}t|VdSr`)._is_slice_element_none_or_constant_or_symbolic)r*rs rKr,z#_index_to_gather..s?77@DD777777rLzhArray slice indices must have static start/stop/step to be used with NumPy indexing syntax. Found slice(rRz). To index a statically sized array at a dynamic position, try lax.dynamic_slice/dynamic_update_slice (JAX does not support dynamically sized arrays within JIT compiled functions).rnr~rzdIndexer must have integer or boolean type, got indexer with type {} at position {}, indexer value {}zEIndexing mode not yet supported. Got unsupported indexer at position : c g|]>\}}tj|tt|||jz?Srj)rrrGrrE)r*grDgather_indices_shapes rKr2z$_index_to_gather..sU,","," !Q 12E%1qv::N:N4O4OPP,",","rLr) rrrrrrrrr)7rrrrGrHr!r"_is_advanced_int_indexerrrNr}rrr6r enable_x64rrrrkr?extendr8rrrxrFr"r!r rrrrrrrr@r_preprocess_slicerrrmrTrPrrr rrrrErrr))r rpr rrDadvanced_axes_are_contiguousadvanced_indexesidx_advanced_axesx_advanced_axes idx_no_nonesadvanced_pairsx_axisy_axiscollapsed_y_axisrrrrhrrrrridx_posr?rE abstract_i i_convertedrnrr slice_sizergather_indices_arrayrrlast_dimrrrrs)` @@@rKrr"s "#g,,44#%Z$Y9S>>$Y$Y$Y MMMMM M MC7mmG $ % % nnQGnnG"':>&(+//c"" QGGy~~GGGLFF*3L*A*AFFFN77777'5777n;>;O8'#'rw7H/I/IQ/N(O(O#P#P & & "+(*#%/GGwGGGGG )3e+ -/.$& "+!#,$&/&(cNNb7b7jgq $ % %*15Fq5I*I*I )+J.5ll)+;<q!'e ZZd*++i44444"24444ne#_---!!/222 nf$### kf"""=##jj jjj*}k:;;A7Z@P@PA7 wv 2 2RPFPPPQQQ2C J 1gfo . . .a,Q <a ! DAq?1qvi88'((H"""?,",","," ,",","  $ $$ (>O,,   % |$$)# '#t+'4/% ' ' ' 's,J JJct|tjtfrtj|dkp(t|t t fp |tup|duS)z/Helper for _eliminate_deprecated_list_indexing.rN)rFr}rr,rErrrrZs rK_should_unpack_list_indexr0s[ QU+ , , @q ( He, - - ( (] (4i)rLct|tslt|trTt|ttjt fs-td|Drd}nd}t||f}|S)Nc34K|]}t|VdSr`)r0rs rKr,z6_eliminate_deprecated_list_indexing.. s+ 7 7a &q ) ) 7 7 7 7 7 7rLzUsing a non-tuple sequence for multidimensional indexing is not allowed; use `arr[tuple(seq)]` instead of `arr[seq]`. See https://github.com/google/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/google/jax/issues/4564 for more information.) rFrGrr,r}rrAr6rx)rprns rKrrs C  #x  C%S9Q)R)R 7 73 7 7 7 7 7VUU cNN Fc *rLc tj|}n#t$rd}YnwxYwt|trt |jtp/t|to|otd|DS)Nc3K|]:}t|o&tt|tjV;dSr`) _is_scalarrTr[r}rr*rs rKr,z$_is_boolean_index.. sV/:/:230:!}}0.BH--/:/:/:/:/:/:rL) rrrxrFr!rTrPrrHr)rDr*s rK_is_boolean_indexr7 sq!!JJ JJJ Z - - U*Z=Mu2U2U : 4 :Q:3/:/:78/:/:/:,:,:;s  &&c .g}t|}td|D}|dkrtd|dkrtd|D}d}d}t|D]\}} t j|} n#t $rd} YnwxYwt|rt|tr#t|}t j|} t| turtj| t|dkr#|t#|nt%|} t||z|z } || | t|z} | | krtd|d| d | |t)j|n|||t,urt||z dz }||dz }t/|S) z=Converts concrete bool indexes into advanced integer indexes.c3(K|] }|tuVdSr`rr6s rKr,z'_expand_bool_indices.. s&00qQ(]000000rLrz0an index can only have a single ellipsis ('...')c3lK|]/}||tu t|rt|ndV0dSr)rr7rr6s rKr,z'_expand_bool_indices.. sS== !8*;*;"31!5!5.P s N NDE d @a8m @z!U';'; @ qMM ?jBJ?? N N N N N NrLFc3xK|]5}|dup,|tup#t|tpt|V6dSr`)rrFr_is_int_arrayliker6s rKr,z+_is_advanced_int_indexer..S sf 3 3)*$Y%!x-%:a+?+?%!!$$ 3 3 3 3 3 3rL)rFrGrrs rKrrL s C   N NIL N N NNN 5  3 3.1 3 3 3 3 33rLct|trt|t p]tt |ddt jp4t|ttfotd|DS)zDReturns True if x is array-like with integer dtype, False otherwise.rPNc34K|]}t|VdSr`)rGr6s rKr,z$_is_int_arraylike..Z s+1R1R12CA2F2F1R1R1R1R1R1RrL) rFr^rNrTrIr}rrHrGrrZs rKrGrGV s| Q   8Z4%8%8!8 S 7D112: > > S D%= ) ) Rc1R1RPQ1R1R1R.R.RTrLctj|p8t|tjtfotj|dkS)z#Checks if a Python or NumPy scalar.r)r}rrFrr,rErZs rKr5r5\ s> +a.. 2ZBJ+>??1!#q2rLc td|D}||krtd|d|d|ddt|D}t|d}|ut|d3tdt t t |dtdf||z z}|d||z||d zdz}n.||kr(tdf||z z}t||z}|S) zGHelper to remove Ellipsis and add in the implicit trailing slice(None).c3\K|]'}|dup|tupt|t V(dSr`)rrFrNr6s rKr,z,_canonicalize_tuple_index..c sCee\]Q$Y%V!x-%V:aQUCVCV WeeeeeerLzToo many indices for rz# non-None/Ellipsis indices for dim rc32K|]\}}|tu|VdSr`rrs rKr,z,_canonicalize_tuple_index..h s* @ @FAsxa @ @rLNz'Multiple ellipses (...) not supported: r) rrrrrHrrQrrG)arr_ndimrp array_namenum_dimensions_consumedellipsesellipsis_indexcolonss rKrra s[eeadeeeeex''  9  9 9.E 9 9-5 9 9 9 : ::A @inn @ @ @($''. Hd'  KDT34H4H K K K M MMDkk^x*AA BF o~o  '#nq.@.A.A*B BCC))Dkk^x*AA BF **v C *rLrrr8 core.DimSize/tuple[core.DimSize, core.DimSize, core.DimSize]c dd}|j||jnd} |dkrtd|dk n5#tj$r#}tjd |d d |zd}~wwxYwd fd }|j rdndz }n|||jd}|j rnd}n|||jd} r|n| } r||z n||z } tjd| |zdz |z} ||| fS)z=Computes the start index, step, and size of the slice `x[s]`.rr/rBc> tj|S#|cYSxYwr`)rr)rs rKconvert_to_indexz+_preprocess_slice..convert_to_index} s) ^A   hhhsNrrzslice step cannot be zeroz.In slice with non-constant elements the step (rrrDwhichrAcJ |dk}n8#tj$r&}tjd|d|dd|zd}~wwxYw|r/rtj|Stjdz |Srtjd|zStjd|zS)Nrz(In slice with non-constant elements the z (rz/be resolved statically if it is >= 0. Details: rr)rr:min_dimr)rDrYi_ge_0rr8rs rK clamp_indexz&_preprocess_slice..clamp_index sBQff  .BBB  / HU H Ha H H H @Q @ @ A B BBB / .|Iq)))|IM1--- /|Ay1}---|B A ...s ?!:?rrr@)rr/rBr/)rDr/rYrA)rrrr:rr@r) rr8rXrrr]rr@rrr,rs ` @rKrru s&'V%7  !& ! ! !Q$F qyy 2 3 33II ,FFF  -FFFFDDD E F FFF ///////$W_ -AA A EE K((117 ; ;EV^! )99rDD ;''// 8 8D%v#( > hua! fjR!q1u!5666 6 1r6TU:YZ]^Y^K_@`@`9` ``rLc tjt|d}tjt }|dkrt ||Stj||}dtj d|zdz|z |dz z z S)NzM argument of jnp.bartlettrr) rrr^rrrrNrrr)r0rbs rKbartlettre sy S!%ABB!  #F + +%!VV 5>> hua! VZA A & &!a% 0 00rLctjt|d}tjt }|dkrt ||Stj||}ddtj dtz|z|dz z zz S)NzM argument of jnp.hammingrgHzG?gq= ףp?rr_rbs rKhammingrg sz S!%@AA!  #F + +%!VV 5>> hua! vz!b&1*A"6777 77rLctjt|d}tjt }|dkrt ||Stj||}ddtj dtz|z|dz z z zS)NzM argument of jnp.hanningrrrr_rbs rKhanningri sz S!%@AA!  #F + +%!VV 5>> hua! FJq2vzQU3444 55rLbetacPtjt|d}tjt }|dkrt ||Stj||}d|dz z}t|tj d||z |z dzz zt|z S)NzM argument of jnp.kaiserrrr) rrr^rrrrNrrrr)sqrt)ryrjrPralphas rKkaiserrn s S!%?@@!  #F + +%!VV 5>> hua! Q-% D6;qQY%$7A#==>> > ? ?"T(( JJrLc<|\}}tj|dkSrrrrrs rK _gcd_cond_fnrq s &"b a  rLc |\}}t|dk||t|dktj||t|d}}t||k||t||k||fSr)rrremrrps rK _gcd_body_fnrt sw &"b "'2r " " "'372r??Jr1,=,= > > " RR %RR"8"8 99rLc|tjd||tj||\}}tt |t st dt||\}}tj tttj |tj |f\}}|S)Ngcdz,Arguments to jax.numpy.gcd must be integers.)r*rrrTr[rrrkr while_looprqrtr)r0)rrrvrs rKrvrv sub"%%%  r2 & &&"b F2JJ ( (E C D DD B # #&"b >, vz"~~vzRT~~6V W W&#q *rLc tjd||tj||\}}tj|tj|}}t t |tstdt||}t|dkt|dtj |tj ||S)Nlcmz,Arguments to jax.numpy.lcm must be integers.r)r*rrr)r0rTr[rrrvrrr floor_divide)rrrs rKryry sub"%%%  r2 & &&"b :b>>6:b>>b" F2JJ ( (E C D DD "bkk! qAvz!Q''r6#6r1#=#=>> @ @@rLctjd|||tt|t|||S)aReturn the elements of an array that satisfy a condition. JAX implementation of :func:`numpy.extract`. Args: condition: array of conditions. Will be converted to boolean and flattened to 1D. arr: array of values to extract. Will be flattened to 1D. size: optional static size for output. Must be specified in order for ``extract`` to be compatible with JAX transformations like :func:`~jax.jit` or :func:`~jax.vmap`. fill_value: if ``size`` is specified, fill padded entries with this value (default: 0). Returns: 1D array of extracted entries . If ``size`` is specified, the result will have shape ``(size,)`` and be right-padded with ``fill_value``. If ``size`` is not specified, the output shape will depend on the number of True entries in ``condition``. Notes: This function does not require strict shape agreement between ``condition`` and ``arr``. If ``condition.size > arr.size``, then ``condition`` will be truncated, and if ``arr.size > condition.size``, then ``arr`` will be truncated. See also: :func:`jax.numpy.compress`: multi-dimensional version of ``extract``. Examples: Extract values from a 1D array: >>> x = jnp.array([1, 2, 3, 4, 5, 6]) >>> mask = (x % 2 == 0) >>> jnp.extract(mask, x) Array([2, 4, 6], dtype=int32) In the simplest case, this is equivalent to boolean indexing: >>> x[mask] Array([2, 4, 6], dtype=int32) For use with JAX transformations, you can pass the ``size`` argument to specify a static shape for the output, along with an optional ``fill_value`` that defaults to zero: >>> jnp.extract(mask, x, size=len(x), fill_value=0) Array([2, 4, 6, 0, 0, 0], dtype=int32) Notice that unlike with boolean indexing, ``extract`` does not require strict agreement between the sizes of the array and condition, and will effectively truncate both to the minimum size: >>> short_mask = jnp.array([False, True]) >>> jnp.extract(short_mask, x) Array([2], dtype=int32) >>> long_mask = jnp.array([True, False, True, False, False, False, False, False]) >>> jnp.extract(long_mask, x) Array([1, 3], dtype=int32) extreactrY)r*rcompressr)r[rrrZs rKextractr~!sArz9c:>>> % ""E#JJTj Q Q QQrL)rrZrc^tjd|||t|t}|t d|jdkrtd|d}t|}nt||d}|d|j d||j dd}}|d|j d}|,tj |rtd||} nd|cxkr|j dks"ntd|d |j dt|td|j} t| |t!||j }|t%|d d d|} t| d|S) a Compress an array along a given axis using a boolean condition. JAX implementation of :func:`numpy.compress`. Args: condition: 1-dimensional array of conditions. Will be converted to boolean. a: N-dimensional array of values. axis: axis along which to compress. If None (default) then ``a`` will be flattened, and axis will be set to 0. size: optional static size for output. Must be specified in order for ``compress`` to be compatible with JAX transformations like :func:`~jax.jit` or :func:`~jax.vmap`. fill_value: if ``size`` is specified, fill padded entries with this value (default: 0). out: not implemented by JAX. Returns: An array of dimension ``a.ndim``, compressed along the specified axis. See also: - :func:`jax.numpy.extract`: 1D version of ``compress``. - :meth:`jax.Array.compress`: equivalent functionality as an array method. Notes: This function does not require strict shape agreement between ``condition`` and ``a``. If ``condition.size > a.shape[axis]``, then ``condition`` will be truncated, and if ``a.shape[axis] > condition.size``, then ``a`` will be truncated. Examples: Compressing along the rows of a 2D array: >>> a = jnp.array([[1, 2, 3, 4], ... [5, 6, 7, 8], ... [9, 10, 11, 12]]) >>> condition = jnp.array([True, False, True]) >>> jnp.compress(condition, a, axis=0) Array([[ 1, 2, 3, 4], [ 9, 10, 11, 12]], dtype=int32) For convenience, you can equivalently use the :meth:`~jax.Array.compress` method of JAX arrays: >>> a.compress(condition, axis=0) Array([[ 1, 2, 3, 4], [ 9, 10, 11, 12]], dtype=int32) Note that the condition need not match the shape of the specified axis; here we compress the columns with the length-3 condition. Values beyond the size of the condition are ignored: >>> jnp.compress(condition, a, axis=1) Array([[ 1, 3], [ 5, 7], [ 9, 11]], dtype=int32) The optional ``size`` argument lets you specify a static output size so that the output is statically-shaped, and so this function can be used with transformations like :func:`~jax.jit` and :func:`~jax.vmap`: >>> f = lambda c, a: jnp.extract(c, a, size=len(a), fill_value=0) >>> mask = (a % 3 == 0) >>> jax.vmap(f)(mask, a) Array([[ 3, 0, 0, 0], [ 6, 0, 0, 0], [ 9, 12, 0, 0]], dtype=int32) r}Nz4The 'out' argument to jnp.compress is not supported.rzcondition must be a 1D arrayrz1condition contains entries that are out of boundszPsize must be positive and not greater than the size of the array axis; got size=z for a.shape[axis]=rnT)rVrW)r*rrSrrNrrErrrr?r(r6rrrrrPr`) r[rrbrrZr condition_arrrextrarrs rKr}r}D!sDz9a<<<)$$++D11-_ T U UU1 3 4 44 \ D ((CC 1dA  C&} ! }5}SYq\]]7S- #]  # #$# \~eL J K KK  FF  $ $ $ $ ! $ $ $ $ F!FF7:y|FF G GG }eAsx&8&8 9 9D c539=== > >C tEEE Fuu MF &!T " ""rL)rowvarbiasddofrrrfweightsaweightsc|4tjd||\}}|jdkrtdntjd|\}|jdkrtdt |}|s|jddkr|j}|jddkr#tgddS|>2q)))!__ AA..L I|,,AAA (rL>rrrr^excludedunrolled sorted_arrqueryr c Z |dkrtnt fd}ttjtjt dz}|d|t f}tj||d||r|nd\}} |dS)NrBc|\}}||zdz}|}t|||t|||fdfS)Nrrjr) staterlowhighmidgo_leftrrrs rKbody_funz(_searchsorted_via_scan..body_fun!sWIC :! Cb 3((G '3 $ $eGS$&?&? @" DDrLrrrj)r5unroll) r%r$r^r}rlog2rrscan) rrrr rPrn_levelsinitcarryrrs `` @rK_searchsorted_via_scanr!s"fnn2E"EEEEEEE Z1!45566 7 7( %((EE#j//** +$ Xhb)18XXq:::(% q/rLc(|j|jztjtjjkrtnt fd}|}|dkr.|tj||gdd|j}n-|tj||gd|jd}tj tj |||tj | |S)Nctjt|}t|jt ||Sr`)rrrrrr`r)rMrp working_dtypes rK_rankz%_searchsorted_via_sort.._rank "sB (=#a&& ) )C c?? gajj ) - -c 2 22rLrBr) rr}rrrrrrrr=rr?r)rrr rPr query_flatrrs @rK_searchsorted_via_sortr "s%?UZ7"(28:L:L:PPP%%V[-33333{{}}* V^^ E#/:z":A>> ? ?  LEE E#/:z":A>> ? ? @P@P QE SWUEE*$5$566 H H O OPU V VVrLc|dkrtnt}tj|d||}||dS)NrBrrpr)rPrb)r$r%rrr)rrr rPr comparisonss rK_searchsorted_via_compare_allr"sL"fnn2E"/Y/// EBB+ u1 - --rL)r methodr)rsorterrc|tjd||ntjd||||dvrt|d|dvrt|dt|dkrtdtj||\}}|||}t |t jt jj krtnt}t |d krt|| Sttd ttd ttd|}|t!|t!|||S) aPerform a binary search within a sorted array. JAX implementation of :func:`numpy.searchsorted`. This will return the indices within a sorted array ``a`` where values in ``v`` can be inserted to maintain its sort order. Args: a: one-dimensional array, assumed to be in sorted order unless ``sorter`` is specified. v: N-dimensional array of query values side: ``'left'`` (default) or ``'right'``; specifies whether insertion indices will be to the left or the right in case of ties. sorter: optional array of indices specifying the sort order of ``a``. If specified, then the algorithm assumes that ``a[sorter]`` is in sorted order. method: one of ``'scan'`` (default), ``'scan_unrolled'``, ``'sort'`` or ``'compare_all'``. See *Note* below. Returns: Array of insertion indices of shape ``v.shape``. Note: The ``method`` argument controls the algorithm used to compute the insertion indices. - ``'scan'`` (the default) tends to be more performant on CPU, particularly when ``a`` is very large. - ``'scan_unrolled'`` is more performant on GPU at the expense of additional compile time. - ``'sort'`` is often more performant on accelerator backends like GPU and TPU, particularly when ``v`` is very large. - ``'compare_all'`` tends to be the most performant when ``a`` is very small. Examples: Searching for a single value: >>> a = jnp.array([1, 2, 2, 3, 4, 5, 5]) >>> jnp.searchsorted(a, 2) Array(1, dtype=int32) >>> jnp.searchsorted(a, 2, side='right') Array(3, dtype=int32) Searching for a batch of values: >>> vals = jnp.array([0, 3, 8, 1.5, 2]) >>> jnp.searchsorted(a, vals) Array([0, 3, 7, 1, 1], dtype=int32) Optionally, the ``sorter`` argument can be used to find insertion indices into an array sorted via :func:`jax.numpy.argsort`: >>> a = jnp.array([4, 3, 5, 1, 2]) >>> sorter = jnp.argsort(a) >>> jnp.searchsorted(a, vals, sorter=sorter) Array([0, 2, 5, 1, 1], dtype=int32) The result is equivalent to passing the sorted array: >>> jnp.searchsorted(jnp.sort(a), vals) Array([0, 2, 5, 1, 1], dtype=int32) Nr)rBr zK is an invalid value for keyword 'side'. Expected one of ['left', 'right'].)r scan_unrolledr] compare_allzl is an invalid value for keyword 'method'. Expected one of ['sort', 'scan', 'scan_unrolled', 'compare_all'].rza should be 1-dimensionalrrnFT)r*rrrErrr}rrrrrrrrrrS)rrr rrrPimpls rKrr"sz ^A....Av666 """ ::: ; ;; CCC   L L L M MM !WW\\ 0 1 11 Q " "$!Q  & Aq66RXbh//333%%%VVq[[ au % % %%,e445t<<$2      $ gajj'!**dE 2 22rL)r c tjd||tjt|d}t |}|jdkrtd||jddkrt|tS|sdnd}t|d |dkt||| t|t|ddd || z S) Ndigitizez right argument of jnp.digitize()rz7digitize: bins must be a 1-dimensional array; got bins=rrnr rBrr )r*rrrrNrSrErr?rrrrr)rMrr bins_arrr s rKrru"sz1d+++  u.P Q Q% T]]( ]a Q$QQ R RR ^A! au % % %% )6$  RLHQK14(((MML$$B$>>>>  rLzUnlike `np.piecewise`, :py:func:`jax.numpy.piecewise` requires functions in `funclist` to be traceable by JAX, as it is implemented via :func:`jax.lax.switch`. See the :func:`jax.lax.switch` documentation for more information. Array | Sequence[ArrayLike]funclist&list[ArrayLike | Callable[..., Array]]c  tjd|t|t|}}||dzkr|dd|ddz}n8||krdgt|z}nt d|d|d|dzd|d t |D}d t |D}t t|t|t |t| g|Ri|S) N piecewiserrrzwith z condition(s), either z or z functions are expected; got c8i|]\}}t|||Srjr)r*rDrs rKrzpiecewise.."s) D D DTQ DAq D D DrLc8i|]\}}t|||Srjr)r*rDrs rKrzpiecewise.."s) ? ? ?DAq8A;; ?1a ? ? ?rLrn) r*rrrHrr _piecewiserSrrr) rMrfrrkwncnfconstsfuncss rKrr"s4{A&&& x==#h--b"26\\}x},HH RxxsT(^^#HH fRffrffr!tffbdff g gg D DYx00 D D D& ? ?Ih// ? ? ?% GAJJ > > >ekkmm,, ! ! ! ! ! !!rLrrdict[int, ArrayLike]+frozenset[tuple[int, Callable[..., Array]]]c  t|  fdtt|dzD}tt jt t|dd|gddd}t|  fd fd  fd|D}ttj d|||S) Ncbg|]+}||,Srj)r)r*rDrfuncdicts rKr2z_piecewise.."s1 O O OfjjHLLOO,, O O OrLrrcfdS)NcB|gRiSr`)r)rMrrPrrs rKrz+_piecewise.._call.."s/QQq&4&&&2&&--e44rLrj)rrrPrs`rK_callz_piecewise.._call"s 4 4 4 4 4 4 44rLcfdS)Nc&tSrmr)rMrPrs rKrz,_piecewise.._const.."sU1E***rLrj)rrPs`rK_constz_piecewise.._const"s * * * * **rLcZg|]'}t|r |n |(Srjr)r*rrrs rKr2z_piecewise.."s8 G G G(1++4eeAhhh66!99 G G GrLrr) rrrrlr(rrrr[r+rswitch) rMrfrrrrrrrrrPrs ` `` @@@@rKrr"s %[[( O O O O OeCMMA>> 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 arrayrYrdropr3) r*rrSrrrrr6rrrr=r?)rrrr0rmask_arrvals_arrrs rKrr"stwT4000$S\\74==%++($ @ ? @ @@ Y(- @ A AA @ > ? ??  K (..""8= Q Q QRS T' 8S\\ 2 2(  ! % %hV % < < D DTZ P PPrLrc@tjd|||t|t|t|}}}|jr|jr|js|St |t |}|rtd|d}n\|dkrt|d|jdz }d}n:|d kr ||jz}d}n'|d krtd td ||j t||j  || 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) putzjax.numpy.put cannot modify arrays in-place, because JAX arrays are immutable. Pass inplace=False to instead return an updated array.Nrrrrpromise_in_boundsrrz-The 'raise' mode to jnp.put is not supported.z1mode should be one of 'wrap' or 'clip'; got mode=r3)r*rrSrrr6rrrrrrr?r) rrrrr0rind_arrv_arr scatter_modes rKrr#s@@uaa((( E#JJaw# UZ J s7|| , ,% @ ? @ @@ \LL v~~7Asx!|,,G&LL v~~ G&LL w M N NN KDKK L LL  gsy11 2 6 6u< 6 P PPrL)r>)r?rr@rArBrC)rMrrBrN)rMrrBr1)rzrQrBr])rrrrNrrNrBr1)rr-rPr1rBr,)rrrrrBr,)rr-rr-rBr,)rr2rr2rBrN)rrrBrN)rrrBr1rr`)rMr,rr,rrArrArr&rrrBr,)r) rr-rr-rrArr&rrrBr,)r)rNN) rr-rr-rrrrrBr,)rNNN) rr-rr-rrrrrrrBr)rMr-rr-rrrrrrrrrBr) r#r-rrrrrrrrrBr&)rr-rJrKrBr,)rJrSrr-rBr,)rrY)rZr-rXr^rJr[rBr,)rZr-rbrcrBr,)rZr,rbrirBr,)rZr-rBr,)F)rr-r~rNrBr,)rrNN) rr-rr^rbr^rrr8rrBr,)NN)rr-rrrrrBr,) rr-rr-rbrcrrrBr)Nr) rr-r?rrrArrrBr,)r)rr-rrArBr,)rr) rrrrrrArrArBr,)rr-r?r3rBr)rr-rr3rBr,)rr-rbrcrBr,)rr,rbrSrBr,)rr-rbrrBr,)rr-rr^rr^rBr,)rr-rrrrrBr,)rr,rrSrrSrBr,)r&r'F) rr-rr-r(r-r)r-r%rNrBr,)NNN)rMr-r@r-rAr-rBrCr rCrDrrBr,) r[r-rMr\rr\rrrZr]rBr) r[r-rMr-rr-rrrZr]rBr,) r[r-rMrrrrrrZr]rBrar~)rfrrgrrhr-rBr,r) rMr-rrrrr^r5rrBr,)rurrBrS)ruryrBrz)rr-rBr)rr-r?rrBr,) rrArr-rrrbr^rBr)rr-rrrbr^rBr)rrArbr^rBr)rrrrrrrrrrrrrBr,r)rr-rr^rrrBr,)rMr-rrrBr,)TrNN) rMr-rrNrr-rrrrrBr,)rr-rrrZr]rBr)rr-rrrZr]rBr,) rr-rrrbr^rDr-rBr,)rrrr^rrArBr)rrrrA)rr,rrrr,rBr,)rr,rrrBr,) rr,rrrrAr/rArBr,)rr,rrrLrMrBr,) rr,rrrVrWrXrrBr,)rr,rrrgrhrBr,)rr-rrprrArr-rVrprLrqr/rA)ru)rr-rr}rr~rBr,)rNN) rrrbr^rrrPrrBr,)rMr-rbr^rBr)rr-rrrBr,)rr-rbrrPrrBr,)rrrbrrPrrBr,)rrrbrrBr,)rrrPrrBr,)rrrBr,)Nr) rr-rrrrrrArBr,)rMr-rr^rBr,)rrrBr)rrrBr,)rBr)rMr-rr-rr-rBr)rr-rBr)NTrr)r|rrPrrrNrrrr^rrrBr,)rrrBr+)rMr-rBr-) rMr-rPrrrNrrrBr,) rrrPrrrrrrrrBr,)rr-rrrBr,) rr<rPrr?rrrrBr,) rBr<rPrr?rrrrBr,) r?rrZr-rPrrrrBr,) rr<rZr-rPrr?rrrrBr,)r?rrPrrrrBr,)rBr)rTr-rUr-r%rNrBr,)rTr-rUr-rBr,) r[r\rPr2r]r^r=r^rBr,)rMrrrrrrBr,)rlrmr?rrPr2rBr,) rtrArPr2r]r^rurArBr,)NrN) r r/ryrzrXr{rPrrrrBr,) r r/ryrzrXr{rPrrBr,)rr/rPrrBr,) rrr@rrrrPrrrrBr,) rrr@rrrrPrrBr,) rr/r@r/rr/rPr2rBr,)rTFNr)rr-r@r-rPr^rQrNrrrPrrbr^rrrBr,)rr-r@r-rPr^rQrNrrrPrrbr^rrrBr)rT)rr-r@r-rPr^rQrNrrNrPrrbr^rrrBr)rTrNr)rr-r@r-rPr^rQrNrr-rPrrbr^rBr,)rTNr)rr-r@r-rPr^rQrNrPrrbr^rBr,) rr-rrNrrNrrArBr)rr-rBr)NF)rrrPrrrrBr,)rrrPrrrrBr)rrrPrrrNrBra) rr-rr-rbrrrrBr,)Nrr) rr-rMrrr-rbr^rBr,) r r^ryrrXr^rPrrBr,)rZr-rXr^rBr,)rrrNN)rr-r=r{rr^rr^rPrrrrBr,)rr^rXr^rZrrBr)rr-rXr^rBr) rr-rr-rrNr0rNrBr,)rr^rEr^rBr)rr-rBr)rrr) rr-r=r^rr^rr^rBr,)rr-rXr^rBr,)rI)rr-rTr-rbrrBr,) rr-rrWrbrrVrNrBr,) rr-rrWrTr-rbrrBr,)rhrrbr^rr-rBr,)rgrmrr-rJrrBr,) rr-rr-rr&rrrBr,) rr-rr-rbr^rr&rrrBr,) rr-rr-rJrrr&rrrBr,)rrArr-rrrrrr&rrrrmrBr,)rr-rJrrrrrrrrr&rrrrmrBr,) rrrrrr&rrrrmrBr,)rrArr-rrrBr) rr-rJrrrrrrBr)rrrBr)rrrr) rr-rr-rr&rr'rBr,)rr-rr-rrrBr,)rrrN)r+r^r,r^r-r^rbr)rr-rr-rBr,)rMr-r rr8rNrBr,)rr-rrrZrrBr,) rr-rbrrrrrrBr,)rr,rbrrrNrBr,)rbrrrNr)rr-rbrrUrrrrVrNrWrNrBr,)rr-rBr,)r^r_rbr^rBr,)rr-rjr^rbr^rBr,)rr,rr,rbrrBr,)rr,rrrbrrBr,)rr-rrrbrcrBr,)rr-rbr^rr^rBr,)Nr)rr-rbrrrArBr,)NNr) rr-rbrr]rrrArBr,)NNNFFN)rr-rr-rbrrrrrrrNrrNrZrrBr,)rbr) rr-rr-rbrrrrZrrBr,)rprrBrN)rr,rprrrrBr)FFNN)T)r rrprr rNrBrr)rrr8rTrBrU)ryr^rBr,)ryr^rjr-rBr,)rrrBr,)rrrBr) r[r-rr-rrrZr-rBr,)r[r-rr-rbrrrrZr-rrrBr,)NTFNNN)rZr-rrrrNrrNrrrrrrrBr,)NT)rMr-rrrrNrBr,) rrNrr,rr,r rArPrQrBr,) rr,rr,r rArPrQrBr,)rBN) rr-rr-r rArrrrArBr,)rMr-rr-r rNrBr,)rMr-rfrrrrBr,) rMr,rfr,rrrrrBr,)rr,rr^rBr,) rr-rr-rr-r0rNrBr,) rr-rr-rr-rrr0rNrBr,(r __future__rr7rcollections.abcrr functoolsr importlibr;rrItypingrrr r r r r textwrapr_dedentrrr}rrrrr jax.shardingrr jax.tree_utilrrrjax._srcrrrjax._src.custom_derivativesrrrrrjax._src.api_utilrjax._src.arrayr jax._src.corer!r"jax._src.lax.laxr#r$r%r& jax._src.laxr jax._src.libr'r!jax._src.numpyr(r)r*jax._src.numpy.vectorizer+jax._src.typingr,r-r.r/r0r1r2r3r4 jax._src.utilr5r6r7r8r9r:rOr;pkg_name import_moduler ImportErrornewaxisr=rJ_PRECISION_DOCr~rar euler_gammarNrget_printoptions printoptionsset_printoptionsrWr?rrErrr[rQr]ry_shaped_abstractify_handlersrruint2uint4ruint16uint32uint64int2int4int8int16rr float8_e4m3fnfloat8_e4m3fnuz float8_e5m2float8_e5m2fnuzfloat8_e4m3b11fnuzrrrsinglefloat64double complex64csingle complex128cdoubleruintrrvcomplex_genericnumberrrUrr signedintegerrflexible characterobject_rrIrPcan_cast promote_typesr6 array_str array_reprsavesavezrrrNr^rrrrrrrrrrTriterablerr(_CONV_PREFERRED_ELEMENT_TYPE_DESCRIPTIONrrrrr rr_ARRAY_VIEW_DOCrrIrRrVr]rrerortryr}rr _EDIFF1D_DOCrrrr=rr9rrrr rrrrr+rVrFrrqr:rxrkrrrrrrrrregisterraroundrround_rrrrdrrrrGrrrrr$r.rBrKrUrarfrlr|r"rjrrrrrrrrrrrrrrrrr _ARRAY_DOCrrrrrSrrrrcr7rr?rrNrwrKrWrZr`rdrgrhrsrxrr}rrrrrrrrrrrrdefjvprr>rrDrrrr r r mask_indicesrr$r&r,r/r2r5r9r;r?r>_SCALAR_VALUE_DOCrDrPrSr8rYr"rjrorrr~rrrpaths PathOptimizerrrwrrrrrrrr*r/r5r:r=rlr@rLrG _NANARG_DOCrKr rJrSrRr]r\rar`rlrwr~rrrrrrrrrrrrrrrrrrrr rr0rr7rrrrGr5rrrcrergrirnrqrtrvryr~r}rrrrrrr_PIECEWISE_DOCrrr6rrrjrLrKr8s >   #"""""........  ..................&&&&&& 77777777==========222222!!!!!!111111$$$$$$44444444BBBBBBBBBBBB,,,,,,))))))%%%%%%!!!!!!......000000000000000000 4  H 3I3 +++  E !!! !  GCLL 33333"UDn ff& &%*%*%*%*Nwu w,,,,11111$111$PPP5M%k2 "(## <  FL ) )%&,''"(##  29 % %  29 % %  29 % % ;  6; ' '$%%!!"(##"(##"(##!!&"677 ##F$:;; 233 ##F$:;;&&v'@AA  V_ - -  BJ ' '$$RZ000&$$RZ000&'' 555 G((777 W rx''uuU ))vvv"*44gg'AAAA2<7799Z *  *$ ; * $ ; L *    ?$ $ L ]  w 7<! / / / / / /t 8 - &3&3&3&3RU+++    ,+  )))???*)?)))BBB*)B''' 'BBBB ;  ###! #'***MMM+*M,( SSSTTT59$!$!$!$!UT$!N MNNNGS(,8<GSGSGSGSGSONGST MNNNQS)-9=QSQSQSQSQSONQSh'((8:DH48AAAA)(A2.026*.%).  PRMQ,0'+""""! "$  GIMQ,0'+7 7 7 7 ! 7 t K!K!K!K!K!\^T2233   43 2 2 2 2 j?;;;m,,,++++-,<;+29C9C9C9C9Cv i(((FFFF)(F42%%%%,%%%%. ug&&&/3/3/3/3'&/3dm,,,/1%)$(2 2 2 2 -,2 h \:::7;)-    ;: <.9994555(,! D7D7D7D7D765:9D7NFFI^00= ^0^0^0^0^0^0B j6661'1'1'1'761'j9<XXXXXv<9<9<9<9|n---!!!.-!&9W9W9W9W9Wv i55565C"C"C"C"L 0>>>+&+&+&?>+&\25252525h 7EEE    FE   n---SX#N N N N .-N d+/+/&*; ; ; ; ; |'   +/+/&* 7 7 7 7   7 37!&<@AE&&&&& &  !AE   6: $.?CAE..... . H(H(H(H(H(H(V;;;;;$8<QD9=QDQDQDQDQDQDf DDD D === =/6677''87'$7''''3**** $H$H$H$H$HL?;;;>>>><;>      q ) ) ) q ) ) ) q ) ) )  DDDD! D ./// G "/,9MOO,9MOOGGGGGGR000m,,,-,10<  eW---AAAA.-AAD*.*.      * n---;@8=,>,>,>,>.-,>^15CGh h h h h h V59GK*@*@*@*@*@*@Zi(((59q2v    )( 6Q Xhqk%::; q!tc! "55555(555 &P&P&P&PR''''    &BBBBJ(B%%%%P     _---2,2,2,.-2,j* *4$^$^$^$^  $^Rw///EI;;;;0/;(Y--..f%%%,-%%%%%&%/.%@@@@"26 - - - - -  @D! 4Xt,,--AB22222.-2 %) 0 0 0 0 0%) I I I I I%) 0 0 0 0 0!!"!000)0BBBB10B4CCCC           5/RRR===SR=      5/RRR===SR=      5/RRR - - -SR -   ,---:EEI01i37iiiii iX     8999$15>1>1>1>1>1>1BZGL#'26LLLLL L$*555****65* *. 'T6:'T'T'T'T'T'TV)-'T59'T'T'T'T'T'TV*. 'H6:'H'H'H'H'H'HT$(-G/3-G-G-G-G-G-Gb@D5G595G5G5G5G5G5Gp!X04!X!X!X!X!X!XH!X/3!X!X!X!X!X!XH ,04 , , , , , ,D;;;;&&&&&R####P7<aXXXX X ```$```"]D11DEI$(222222 !!',FFFFF"!F/42RRRR R)-"&826888888v*."&)))))&BKODHL48LLLLLL^LPEI&F&F&F&F&FR<<<<. ;=>C'+J7; JJJJJ J  (,X7; XXXXX X  ;="U'+37 UUUUU U  ;=49'+`7; ````` ` ,<>49'+T7; TTTTT T WXXX<>5:(,608< 6060606060YX60r;=6:9:BBBBB BCCC<>7;:;BBBBDCB"QU:;=====  BCCCRV;<....DC.*o>>>*.u!?>* 888 8>> >3333l AE%*:::: : @@@@ @ AE DDDD DAE @@@@@(M,-1M,M,M,M,M,M,`[''"gt*D*DEEFFi(((HKGGGG)(GFG&5-5-5-5-5-p f%%%9I9I9I9I&%9Ix f%%%=I=I=I=I&%=I@w///9:::RS6: 7 7 7 7;:0/ 7   &%bo66 22277777t77777t6969696969r6969696969rNP"&NPNPNPNPNPNPb!! % % % %"! %%&& % % %'& %o>>>:;;;9:7777<;?>7"/:::%%%%;:% f%%% 4 4&% 4 .?@@@     A@  %%% %%%%% i(((:>21212121)(21pv> #( v>v>v>v>v>v>r"1 1 1 1 1 h$%%   &% #$$   %$ " EdSSS#'37X^X^X^X^X^TSX^v EdSSS&*6:w^w^w^w^w^TSw^t EdSSS $/3,<,<,<,<,<TS,<^<>&*6:4<4<4<4<4<4B+/4B4B4B4B4BTS4Bnw///T////0//ABBB?A!CB6 = = = =1222;@MMMM32M0#' >2>2>2>2>2>2B000>B#'****10* 24@@@ ; ; ; ;A@ ;000>B#'****10* 24@@@ ; ; ; ;A@ ; {/A/A%/H/HW\V]^^^ ````_^` 2333PPPP43P{/A/A%/H/HX]W^___ `````_` 2333PPPP43P OPPP;K;K;K;K;K;KQP;K|!!GGG"!G i((( [ [ [ [)( [  OPPPLMLMLMLMLMLMQPLM^ ufo...B!B!B!B!/.B!J ufo...I!I!I!I!/.I!X T"""    #"   V$$$   %$ ,0 * * * * *  /000="="="="10="@2333;@$$$$43$:;<<< &&&&=< &@ $&*T&T&T&T&T&n deee>BEI3R3R3R3Rfe3Rl G G G <=== 04&* _R_R_R_R>=_RHVVVV8888   QQQ N N N N bHM*.3333<#.#.#.J"""""z""":)))6    <<<04L'L'L'L'L'\)))    .;;;)))X333TTT 222     (9!9!9!9!xaaaa111188886666KKKK!!!!:::: (((   )( (((@@@)(@#':R:R:R:R:R:Rz[##'PT[#[#[#[#[#[#|8999AE/3%)%)?=?=?=?=:9?=Dk***    +* & \\\***   +*  W W W W....  01119?,0U3CIU3U3U3U3U321U3nj)))    *)  ~>>>!!!?>!" wi((( D D D)( D0000HQHQHQHQHQHQX UQ48UQUQUQUQUQUQUQUQsD22D<;D<