uki^,dZddlmZddlmZddlZddlZddlmZddl Z ddl m Z ddl mZmZmZddlmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZmZmZddlm Z ddl!m"Z"m#Z#e#dZ$dZ%e$GddZ&e$dd ddZ'y)z#Tools to create numpy-style ufuncs.) annotations)CallableN)Any)api)Array ArrayLike DTypeLike) control_flow)slicing)lax)indexing) lax_numpy) _moveaxis)check_arraylike _broadcast_to_where) vectorize)canonicalize_axis set_modulez jax.numpyzBecause JAX arrays are immutable, jnp.ufunc.at() cannot operate inplace like np.ufunc.at(). Instead, you can pass inplace=False and capture the result; e.g. >>> arr = jnp.add.at(arr, ind, val, inplace=False) c eZdZdZddddddddd d#dZedZedZedZedZ ed Z d$d Z d%d Z d&d Z ddd d'dZej dgdZej gd d( d)dZ d* d+dZej gd d, d-dZ d. d/dZej dgdgd0dd d1dZd2dZej gd d, d3dZ d. d4d Zej dg!d5d"Zy)6ufuncat Universal functions which operation element-by-element on arrays. JAX implementation of :class:`numpy.ufunc`. This is a class for JAX-backed implementations of NumPy's ufunc APIs. Most users will never need to instantiate :class:`ufunc`, but rather will use the pre-defined ufuncs in :mod:`jax.numpy`. For constructing your own ufuncs, see :func:`jax.numpy.frompyfunc`. Examples: Universal functions are functions that apply element-wise to broadcasted arrays, but they also come with a number of extra attributes and methods. As an example, consider the function :obj:`jax.numpy.add`. The object acts as a function that applies addition to broadcasted arrays in an element-wise manner: >>> x = jnp.array([1, 2, 3, 4, 5]) >>> jnp.add(x, 1) Array([2, 3, 4, 5, 6], dtype=int32) Each :class:`ufunc` object includes a number of attributes that describe its behavior: >>> jnp.add.nin # number of inputs 2 >>> jnp.add.nout # number of outputs 1 >>> jnp.add.identity # identity value, or None if no identity exists 0 Binary ufuncs like :obj:`jax.numpy.add` include number of methods to apply the function to arrays in different manners. The :meth:`~ufunc.outer` method applies the function to the pair-wise outer-product of the input array values: >>> jnp.add.outer(x, x) Array([[ 2, 3, 4, 5, 6], [ 3, 4, 5, 6, 7], [ 4, 5, 6, 7, 8], [ 5, 6, 7, 8, 9], [ 6, 7, 8, 9, 10]], dtype=int32) The :meth:`ufunc.reduce` method performs a reduction over the array. For example, :meth:`jnp.add.reduce` is equivalent to ``jnp.sum``: >>> jnp.add.reduce(x) Array(15, dtype=int32) The :meth:`ufunc.accumulate` method performs a cumulative reduction over the array. For example, :meth:`jnp.add.accumulate` is equivalent to :func:`jax.numpy.cumulative_sum`: >>> jnp.add.accumulate(x) Array([ 1, 3, 6, 10, 15], dtype=int32) The :meth:`ufunc.at` method applies the function at particular indices in the array; for ``jnp.add`` the computation is similar to :func:`jax.lax.scatter_add`: >>> jnp.add.at(x, 0, 100, inplace=False) Array([101, 2, 3, 4, 5], dtype=int32) And the :meth:`ufunc.reduceat` method performs a number of ``reduce`` operations between specified indices of an array; for ``jnp.add`` the operation is similar to :func:`jax.ops.segment_sum`: >>> jnp.add.reduceat(x, jnp.array([0, 2])) Array([ 3, 12], dtype=int32) In this case, the first element is ``x[0:2].sum()``, and the second element is ``x[2:].sum()``. N)namenargsidentitycallreduce accumulateatreduceatc |j|_|xs |j|_|tj|tj|tj|xs||||| | | d |_y)N) funcninnoutrrrrrrr)__doc____name__operatorindex_ufunc__static_props) selfr!r"r#rrrrrrrrs S/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/numpy/ufunc_api.py__init__zufunc.__init__|sh<zufunc.s 3 3F ;r,c |jdS)Nr"r.r/s r*r0zufunc.sd11%8r,c |jdS)Nr#r.r/s r*r0zufunc.st226:r,c |jdS)Nrr.r/s r*r0zufunc.s 3 3G <r,c |jdS)Nrr.r/s r*r0zufunc.s4#6#6z#Br,ct|j|j|j|j|j |j fSN)hash_funcr%rr"r#rr/s r*__hash__zufunc.__hash__s; T]]DMM499djj2 33r,c8t|txr|j|j|j|j |j |jf|j|j|j|j |j |jfk(Sr6) isinstancerr8r%rr"r#r)r)others r*__eq__z ufunc.__eq__sn eU # Y zz4==$--499djjQ {{ENNENNEIIuzz5;;WXYr,c"d|jdS)Nz )r%r/s r*__repr__zufunc.__repr__s $-- ++r,)outwherect|jg||td||td||jdxs |j}||S)Nout argument of zwhere argument of r)rr%NotImplementedErrorr(_call_vectorized)r)r@rAargsrs r*__call__zufunc.__call__siDMM)D)  "24& 9 ::  "4TF ; <<   v & ?$*?*?D ;r,r))static_argnamesc2t|j|Sr6)rr8)r)rFs r*rEzufunc._call_vectorizeds 9TZZ $ ''r,)r)axisdtyper@keepdimsrc\t|jd||jdk7r td|jdk7r td|t d|jd|t|jd||}t|jd||j |td|jd tj|tk7r!td tj||jd xs |j}||||||| S) aFReduction operation derived from a binary function. JAX implementation of :meth:`numpy.ufunc.reduce`. Args: a: Input array. axis: integer specifying the axis over which to reduce. default=0 dtype: optionally specify the type of the output array. out: Unused by JAX keepdims: If True, reduced axes are left in the result with size 1. If False (default) then reduced axes are squeezed out. initial: int or array, Default=None. Initial value for the reduction. where: boolean mask, default=None. The elements to be used in the sum. Array should be broadcast compatible to the input. Returns: array containing the result of the reduction operation. Examples: Consider the following array: >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6]]) :meth:`jax.numpy.add.reduce` is equivalent to :func:`jax.numpy.sum` along ``axis=0``: >>> jnp.add.reduce(x) Array([5, 7, 9], dtype=int32) >>> x.sum(0) Array([5, 7, 9], dtype=int32) Similarly, :meth:`jax.numpy.logical_and.reduce` is equivalent to :func:`jax.numpy.all`: >>> jnp.logical_and.reduce(x > 2) Array([False, False, True], dtype=bool) >>> jnp.all(x > 2, axis=0) Array([False, False, True], dtype=bool) Some reductions do not correspond to any built-in aggregation function; for example here is the reduction of :func:`jax.numpy.bitwise_or` along the first axis of ``x``: >>> jnp.bitwise_or.reduce(x, axis=1) Array([3, 7], dtype=int32) z.reducez'reduce only supported for binary ufuncszz)ufunc._reduce_via_scan..s@a$Q1@s #z tuple of axes)rOrz'zero-size array to reduction operation z which has no identityc ||jSt|||j|Sr6)astyper)ivalrZrKr)rAs r*body_funz(ufunc._reduce_via_scan..body_fun,sI CQu-..eAhS#a&--*> ?EEr,)r"r#r asarrayrr eval_shaper8_onerKrshaper;tuplerDrXravelrrrQr%fullr^r fori_loopreshape) r)rZrJrKrLrPrA final_shapera start_index start_valueresults `` ` ` r*rTzufunc._reduce_via_scans? 88q=TYY!^+ + ++c C g }nnTZZ# FLLe E399-e$ @4@ @d  00  SXXo  IIKc    d tSXX .d C %4(C!Cciiq .BC @ %4(@399TAXY+?@  qy c4 #c  %q) yy|q B4==/Qghii XXk7E 22FkFkkk K 8 ? ? F RSRT VK  # #K1x UF~~k*f Mr,)r)rJrKc|jdk7r td|jdk7r td|td|jd|j dxs |j }||||S) aAccumulate operation derived from binary ufunc. JAX implementation of :func:`numpy.ufunc.accumulate`. Args: a: N-dimensional array over which to accumulate. axis: integer axis over which accumulation will be performed (default = 0) dtype: optionally specify the type of the output array. out: Unused by JAX Returns: An array containing the accumulated result. Examples: Consider the following array: >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6]]) :meth:`jax.numpy.add.accumulate` is equivalent to :func:`jax.numpy.cumsum` along the specified axis: >>> jnp.add.accumulate(x, axis=1) Array([[ 1, 3, 6], [ 4, 9, 15]], dtype=int32) >>> jnp.cumsum(x, axis=1) Array([[ 1, 3, 6], [ 4, 9, 15]], dtype=int32) Similarly, :meth:`jax.numpy.multiply.accumulate` is equivalent to :func:`jax.numpy.cumprod` along the specified axis: >>> jnp.multiply.accumulate(x, axis=1) Array([[ 1, 2, 6], [ 4, 20, 120]], dtype=int32) >>> jnp.cumprod(x, axis=1) Array([[ 1, 2, 6], [ 4, 20, 120]], dtype=int32) For other binary ufuncs, the accumulation is an operation not available via standard APIs. For example, :meth:`jax.numpy.bitwise_or.accumulate` is essentially a bitwise cumulative ``any``: >>> jnp.bitwise_or.accumulate(x, axis=1) Array([[1, 3, 3], [4, 5, 7]], dtype=int32) rNz+accumulate only supported for binary ufuncsrOz@accumulate only supported for functions returning a single valuerCz .accumulate()rrJrK)r"rQr#rDr%r(_accumulate_via_scan)r)rUrJrKr@rs r*rzufunc.accumulateAs{b xx1} D EE yyA~ Y ZZ  "24==/ O PP$$\2Od6O6OJ ad% 00r,cjdk(rjdk(sJtjdt j Qt jjt jt jj|t|tr tdt|tj }j"dk(r!t j$j&dSt)|dfd}t+j,|ddj/fdj&d\}}t)|d|S)NrNrOz .accumulatez'accumulate does not allow multiple axesrc |\}}t|dk(dj|j|j}|dz|f|fS)NrrO)rr^)carry_r_xyrZrKr)s r*scan_funz,ufunc._accumulate_via_scan..scan_funsZ da aQu-tAHHUOSV]]SXEY/Z [a!eQZ]r,)length)r"r#rr%r rbrrcr8rdrKr;rfrQrnprXsizerhrerr scanr^)r)rZrJrKrxrurns`` ` r*rqzufunc._accumulate_via_scan{s 88q=TYY!^+ +t}}o[137 ++c C }nnTZZ# FLLe |z$. @ AA T2773< 0D xx1} XXciiE ** Cq !C!!(QA e0D,EtTWT]T]^_T`aIAv VQ %%r,inplace)static_argnumsrHT)r}c|rtt|jdxs |j}| |||S||||S)aUpdate elements of an array via the specified unary or binary ufunc. JAX implementation of :func:`numpy.ufunc.at`. Note: :meth:`numpy.ufunc.at` mutates arrays in-place. JAX arrays are immutable, so :meth:`jax.numpy.ufunc.at` cannot replicate these semantics. Instead, JAX will return the updated value, but requires explicitly passing ``inplace=False`` as a reminder of this difference. Args: a: N-dimensional array to update indices: index, slice, or tuple of indices and slices. b: array of values for binary ufunc updates. inplace: must be set to False to indicate that an updated copy will be returned. Returns: an updated copy of the input array. Examples: Add numbers to specified indices: >>> x = jnp.ones(10, dtype=int) >>> indices = jnp.array([2, 5, 7]) >>> values = jnp.array([10, 20, 30]) >>> jnp.add.at(x, indices, values, inplace=False) Array([ 1, 1, 11, 1, 1, 21, 1, 31, 1, 1], dtype=int32) This is roughly equivalent to JAX's :meth:`jax.numpy.ndarray.at` method called this way: >>> x.at[indices].add(values) Array([ 1, 1, 11, 1, 1, 21, 1, 31, 1, 1], dtype=int32) r)rD_AT_INPLACE_WARNINGr( _at_via_scan)r)rUindicesbr}rs r*rzufunc.atsML  3 44  T " 7d&7&7BY2a>=Bq'1,==r,c n tdvsJtjd|gtjj t j|gdDj t j|j }t fdDtjs|SDcgc](}t|trt!j"|*}}|xrt j$|}|s@|j&j)|j&j+gSrmt-dg|dj"t|d}|j.t1j2|gdj"t|dfDcgc].}t|tr|nt-||j50c}fd} t7j8| d|fdtd\} } | dScc}wcc}w)N>rrOz.atc3FK|]}tj|ywr6)r rd)rYargs r*r[z%ufunc._at_via_scan..s5Tchhsm5Ts!c3fK|](}tj|j*ywr6)r rbr^)rYrrKs r*r[z%ufunc._at_via_scan..s%@CS!((/@s.1rc|\}tfdD}|j|j|j|jgfdD}dz|f|fS)Nc3LK|]}t|tr|n|ywr6)r;slice)rYindr_s r*r[z7ufunc._at_via_scan..scan_fun..s#OC/#SV;Os!$c3(K|] }| ywr6r\)rYrr_s r*r[z7ufunc._at_via_scan..scan_fun..s/G3A/GsrO)rfrsetget)rtrvrUidxr_rFrr)s @r*rxz$ufunc._at_via_scan..scan_funsb da OwO Oc $$s)--QTT#Y]]_H/G$/GH Ia!eQZ]r,rO)lenrr%rrcr8r rdrKrbr^rfr "eliminate_deprecated_list_indexingr;rrzrebroadcast_shapesrrrrrjmathprodrgr r|) r)rUrrFr_shapesrerrrxrtrurKs ` `` @r*rzufunc._at_via_scans t9  t}}oS)14t4 NN4::sxx{ U5Tt5T U [ [E Ae$A @4@ @D99'BG  h#* Ga*Q2Fbhhqk GF G  4s++V4E  TT']  tADDM$5$5$7?$? @@ $q'#HU#HT!W]]3u:;-G#H Icckk$))E*HT!W]]3u:;-GH Jd_fgX[je,s-U2K2Q2Q2SSgG   Aq64WQZIHE1 8O!HhsH-H-3H2c|jdk7r td|jdk7r td|td|jd|j dxs |j }|||||S) aXReduce an array between specified indices via a binary ufunc. JAX implementation of :meth:`numpy.ufunc.reduceat` Args: a: N-dimensional array to reduce indices: a 1-dimensional array of increasing integer values which encodes segments of the array to be reduced. axis: integer specifying the axis along which to reduce: default=0. dtype: optionally specify the dtype of the output array. out: unused by JAX Returns: An array containing the reduced values. Examples: The ``reduce`` method lets you efficiently compute reduction operations over array segments. For example: >>> x = jnp.array([1, 2, 3, 4, 5, 6, 7, 8]) >>> indices = jnp.array([0, 2, 5]) >>> jnp.add.reduce(x, indices) Array([ 3, 12, 21], dtype=int32) This is more-or-less equivalent to the following: >>> jnp.array([x[0:2].sum(), x[2:5].sum(), x[5:].sum()]) Array([ 3, 12, 21], dtype=int32) For some binary ufuncs, JAX provides similar APIs within :mod:`jax.ops`. For example, :meth:`jax.add.reduceat` is similar to :func:`jax.ops.segment_sum`, although in this case the segments are defined via an array of segment ids: >>> segments = jnp.array([0, 0, 1, 1, 1, 2, 2, 2]) >>> jax.ops.segment_sum(x, segments) Array([ 3, 12, 21], dtype=int32) rNz)reduceat only supported for binary ufuncsrOz>reduceat only supported for functions returning a single valuerCz .reduceat()rrp)r"rQr#rDr%r(_reduceat_via_scan)r)rUrrJrKr@rs r*rzufunc.reduceats}N xx1} B CC yyA~ W XX  "24==/ M NN"":.I$2I2IH AwT 77r,c  tjd|tjt j |}t |dk(sJ|d}jdk(rtdj|jdk7rtd|j| j}tttfr tdtjt j|}tj t#j$|jtt'j(t'j*|j}t-j.|d|jdz  t-j.|d|j  fd}t1j2dj||S) Nz .reduceatrOrz7reduceat: a must have 1 or more dimension, got a.shape=z=reduceat: indices must be one-dimensional, got indices.shape=z(reduceat requires a single integer axis.rJc t|kD|kz|tjtj|d|S)N)rr)rr taker expand_dims)r_r@rUrJind_end ind_startr)s r* loop_bodyz+ufunc._reduceat_via_scan..loop_body sD Q]q7{3hmmAsq$/GdSTr,)rr%r rbr rrrXrQrerKr;rflistrrrjnpappendrzdeletearanger slice_in_dimr ri) r)rUrrJrK idx_tupler@rrrrs `` ` @@r*rzufunc._reduceat_via_scan st}}oY/G< AA;;GDI y>Q  lGvv{ Q S TT||q WHXY ZZ }gge |z$ 6 A BB T166 *D --7 .C //#**Waggdm<#' "))CHH2Et(L#M OC$$S!SYYt_q-@tLI""3399T?FG  ! !!QWWT]Is CCr,)r~c|jdk7r td|jdk7r tdt|jd||d}t j t j |dd||||}|jgtj|tj|S) aApply the function to all pairs of values in ``A`` and ``B``. JAX implementation of :meth:`numpy.ufunc.outer`. Args: A: N-dimensional array B: N-dimensional array Returns: An array of shape `tuple(*A.shape, *B.shape)` Examples: A times-table for integers 1...10 created via :meth:`jax.numpy.multiply.outer`: >>> x = jnp.arange(1, 11) >>> print(jnp.multiply.outer(x, x)) [[ 1 2 3 4 5 6 7 8 9 10] [ 2 4 6 8 10 12 14 16 18 20] [ 3 6 9 12 15 18 21 24 27 30] [ 4 8 12 16 20 24 28 32 36 40] [ 5 10 15 20 25 30 35 40 45 50] [ 6 12 18 24 30 36 42 48 54 60] [ 7 14 21 28 35 42 49 56 63 70] [ 8 16 24 32 40 48 56 64 72 80] [ 9 18 27 36 45 54 63 72 81 90] [ 10 20 30 40 50 60 70 80 90 100]] For input arrays with ``N`` and ``M`` dimensions respectively, the output will have dimension ``N + M``: >>> x = jnp.ones((1, 3, 5)) >>> y = jnp.ones((2, 4)) >>> jnp.add.outer(x, y).shape (1, 3, 5, 2, 4) rNz&outer only supported for binary ufuncsrOz;outer only supported for functions returning a single valuez.outercVtj|tj|fSr6)r rjrzr{)As r*r0zufunc.outer..Qss{{1rwwqzm4r,)NrrN) r"rQr#rr%rvmaprjrzre)r)rB_ravelrns r*outerz ufunc.outer&sL xx1} ? @@ yyA~ T UUt}}oV,a3 4F ;SXXchhtY/ ;F1Ivay QF 6>> 5288A; 5! 55r,)r"intr#rr!Callable[..., Any]rz str | Noner int | NonerrrCallable[..., Any] | Nonerrrrrrrr)returnr)r<rrrS)rstr)rFrr@NonerArrr)rNNFNN)rUrrJrrKDTypeLike | Noner@rrLrSrPArrayLike | NonerArrr)rNFNN)rZrrJrrKrrLrSrPrrArrr)rNN) rUrrJrrKrr@rrrr)rZrrJrrKrrrr6) rUrrrrrr}rSrr)rUrrrrFrrr) rUrrrrJrrKrr@rrr) rUrrrrJrrKrrr)rrrrrr)r% __module__ __qualname__r$r+propertyr8r"r#rrr9r=r?rGrjitrErrTrrqrrrrrr\r,r*rr0sIX#'#'#15377;/359"!  /  1 5-3< ; <%89# : ;$ < =% B C(3Y ,48t 377F8$(%( 377GH45'+SW'+D^$D^D^)-D^@PD^%D^16D^ID^L^bKO15<!%<8H<.<:?<| 37745NR!7171&+71671r>?59&"2&>C&. 3771# {;)>)>)>"')><)>V8 37745=>;?.8&.848.8DI.86.8`HI37D 0D>> import operator >>> add = frompyfunc(operator.add, nin=2, nout=1, identity=0) Now all the standard :class:`jax.numpy.ufunc` methods are available: >>> x = jnp.arange(4) >>> add(x, 10) Array([10, 11, 12, 13], dtype=int32) >>> add.outer(x, x) Array([[0, 1, 2, 3], [1, 2, 3, 4], [2, 3, 4, 5], [3, 4, 5, 6]], dtype=int32) >>> add.reduce(x) Array(6, dtype=int32) >>> add.accumulate(x) Array([0, 1, 3, 6], dtype=int32) >>> add.at(x, 1, 10, inplace=False) Array([ 0, 11, 2, 3], dtype=int32) r)r)r!r"r#rs r* frompyfuncrVsJ tS$ 22r,) r"rr#rr!rrrrr)(r$ __future__rcollections.abcrrr&typingrnumpyrzjax._srcrjax._src.typingrrr jax._src.laxr r r jax._src.numpyr rrjax._src.numpy.reductionsrjax._src.numpy.utilrrrjax._src.numpy.vectorizer jax._src.utilrrexportrrrr\r,r*rs*"$ 77% #+/FF.7 K b6b6b6J"&$3$3+0$3$3r,