ukin |UddlmZddlZddlmZmZddlZddlZddlZddlm Z ddl Z ddl Z ddl Z ddl mZmZmZmZmZmZddlZddlZddlmZddlmZddlmZdd lmZdd lmZdd lmZdd lmZdd lm Z ddlm!Z!ddlm"Z"ddlm#Z#ddlm$Z%ddlm&Z&ddlm'Z(ddlm)Z)ddlm*Z*ddlm+Z+ddlm,Z,ddl-m.Z.ddl/m0Z0m1Z1m2Z2m3Z3ddl4m5Z5ddl6m7Z7ddl8m9Z9ddl8m:Z:ddl8m;Z;ddl8mZ>dd!l?m@Z@dd"l?mAZBdd#lCmDZDmEZEdd$lFmGZGmHZHmIZImJZJdd%lKmLZLdd&lMmNZNdd'lMmOZOdd(lPmQZQdd)lRmSZSmTZTmUZVmWZWmXZXdd*lYmZZZm[Z[m\Z\m]Z]m^Z^m_Z_m`Z`dd+lambZbmcZcmdZdmeZemfZfmgZgmhZhmiZiejZkejZmejZoed,ZpedeqcZqZreeescZsZte,jd-Zvdd.Zwdd0Zxdd1Zydd2Zzdd3Z{edd4Z|e dd5Z|evd6Z|ebdd7Z}d8Z~d9Zd:Zevdd;Zevdd<Zevdd=Zevdd>Zevdd?ZGd@dAej Zevejf ddBZevddCZGdDdEZGdFdGejZevdddHZdddIZevdddJZevdddKZevdddLZevdddMZevdddNZevdddOZevdddPZevddQZevddRZevddSZevddTZevddUZevddVZevddWZevd dXZevdddYZevdddZZevddd[Zevdd\Zevdd]Zevdd^Zevdd_Zevdd`ZevddaZevddbZevddcZevdddZevddeZevddfZevddgZjevddhZlevddiZevddjZevddkZevddlZevddmZevddnZevddoZevddpZevddqZev d!drZ d" d#dvZevd$dwZd%dzZeg d&d|Z d' d(d}Z d)d~ZdZdZdZdZej`dZejeejedte_ee9je<ee9je<e;jeed*dZ d' d+dZiZded<GddejZe̐jed<e̐jed<e̐jed<e̐jed<e̐jed<e̐jed<e̐jed<e̐jed<e̐jed<GddeZGddejZedeeeeefeeefeefZedeeefeefZeeeeeefeeeeeffZ d,dd d-dZddddd d.dZ d/ d0dZejdtGddZ d1dZedgdgfggffdgdgZ d/ d2dZdd d3dZdd d4dZd5dZ ddd d6dZ d7dZd8dZd9dZd:dZ d;dZ ddZeb d?dZ d@dZdAdZdAdZdAdZdAdZdAdZdAdZdd dBdZdBdZdBdZdBdZdBdZdBdZdBdZe dC dDdZe dC dEd„Z dC dFdÄZ dG dHdĄZddŜdIdƄZdJdDŽZdddȜ dKdɄZdLdʄZeeje1<dMd˄Zeeje*j<dNd̄Zdd dOd̈́Zd'dPd΄ZdQdτZdPdЄZdRdфZ dSd҄Z dTdӄZ dTdԄZ d/ dUdՄZ d dVdքZ d dWdׄZdd؄ZddلZevdddڄZevddۄZevdd܄Zevdd݄ZevddބZevdd߄ZevddZevddZevddZej6ee1_ej6ee1_ej6ee1_dZeee1_ddZdZe j@e!jBe.ejDge#jFD]Z$eejJe$<dZ&dZ'dZ( dXdZ)dZ*dXdZ+e e+eZ,dZ-dtdsddZ.dZ/dZ0dZ1 dYdZ2e e2eGZ3dZ4dZ5 dZdZ6dd d[dZ7dZ8ejrhZ:ejvhZZe;jee e7eOj8d?Ze9jeed@ZdAZe,e:ee8eje<e,e:ee,eAd]Ze;jee e7eOjBe,eAd^Ze;jee e7eOjFd_Zd`ZdaZe2eGeFeFgdbecZddeːde<ee9je<ee9je<e;jee e7eOjPdfZdgZe3eFeFgdhZee9je<ee9je<e;jee e7eOjVdiZe3eFeFgdjecZe9jedkdle9j\edmdne;jee e7eOj^doZe3eFeFgdpZe9jedqdree9je<e;jee e7eOjde3eAe:zeAe:zgdsZe9jedtdue;jee e7eOjhdvZe3eGeGgdyZdweːdx<e9jedydze;jee e7e;jne3eGeGgdxZdweːd{<e9jed|d}e;jee e7e;jre3eAeAgd~Ze9jee;jee e7eOjZe3eAeAgdZe9jee;jee e7eOj\e3eAeAgdZe9jee;jee e7eOj^dZe edeOj|eZe edeOjeZd\dZd]dZe2e&ejeGeGgddtZe9jeīe;jee eÐddse2e&ejeGeGgddtZe9jeūe;jee eÐddse2e&ejeIeIgdZe9jeƫe;jee eÐddse2e&ejeIeIgdZe9jeǫe;jee eÐddse2e&ejeIeIgdZe9jeȫe;jee eÐddse2e&ejeIeIgdZe9jeɫe;jee eÐddse2e&ejeGeGgdZe9jeʫe;jee eÐddte2e&ejeIeIgdZe9je˫e;jee eÐddte2e&ejeIeIgdZe9je̫e;jee eÐddtdZ͐dZΐdZϐdZАdZѐdZҐdZӐdZe#jejhe!jBe#jFZאdZؐdZِdZeJe͐eѐdeҐee ejdeϐeАZܐdZݐeܐjeݫeܐje e jeܫe9jeܐeԫee9je<dZee:je<de:je<ee=je<ee=je<eeje<dZdZe;jeܐedZe0dZeje e jeejee9jedde9je<e:j(ee;jeddZe0dZeje e jeejee9jedde9je<e:j(ee;jeddZdZdZeJeede(ee ejdZe9jee:j(edZe;jeedZ d^dZdZdZ d^dZdZdZdZdZdd d_dZd„ZdÄZdsdĜ d^dńZ d^dƄZ d^dDŽZdȄZd`dɄZeJeedʐee ejdʫee˫Zd̄Zd̈́Ze9j\eeeejeeeeثZee:je<d΄e:je<eeje<dadτZdbdЄZdbdфZ dcd҄Z d dddӄZ dedԄZ dՄZ dd֜ dfdׄZ e;jee dD]'Z e;jee e e ֫e ֫)GdلdejZ dgdۄZ dhd܄Z did݄ZdބZ d^d߄Z djdZdZ dkdZdZdZdZ d^dZeJeede ejdZee9je<ee9je<ee:je<de:je< d/ d2dZddd dldZe;jee;jedsdD]'Z e;jee ee ֫e ֫)dZdZdZ dZ!dZ"dZ#dZ$dZ%dZ& dmdZ'dZ(ej`dZ)e)je(e)je e je)e%e9je)<e!e9je)<e"e:je)<de:je)<e#e=je)<e&e=jTe)<e$e=jVe)<e ejXe)<e;je)e'dZ-dZ.e e.eGeGeGeGgdZ/dZ0eJe-e/de.e ejdUZ1e9je1ddde0e:jde1<e;je1e e7eOjrdZ3dZ4dZ5dZ6dZ7dZ8d Z9eJe3e6d e4e ejd e5 Z:e9je:e7e7e9je:<e8e:jde:<d Z;e;je:e;d Z<dZ=dZ>dZ?dZ@dZAdZBdZCej`dZDdteD_eDje eIeDe<e=e>eBeCeDje e jeDe9jeDe?e@e:jdeD<e;jeDeAdZEdZFdZGdZHdZIeJeFeEdeGe ejdUZJe9jeJeHeIe:jdeJ<dZKe;jeJeKdZLdZMdZNd ZOd!ZPd"ZQd#ZReJeMeLd$eNe ejd$eO ZSe9jeSeQeRe:jdeS<d%ZTe;jeSeTdnd&ZUd'ZVd(ZWd)ZXd*ZYd+ZZd,Z[d-Z\d.Z]d/Z^d0Z_d1Z`d2Zad3Zbd4ZceJeVe_d5eYe ejd5UZde9jede`eae:jed<d6e:jed<e;jedebe^ejXed<ece=jVed<d7Zed8Zfd9ZgeJeeeGd:efe ejd:UZhe9jehd;ege:jdeh<d<Zie;jeheid=Zjd>Zkd?Zld@ZmdAZndBZoeJejeGdCeke ejdCelem˫Zpe9jepdDene:jdep<e;jepeodEZqdFZrdGZsdHZtdIZudJZvdKZwdLZxdMZyeJeqesdNetere ejdNZzewe9jez<eue9jez<eve:jez<dOe:jez<e;jezeydPZ{dQZ|dRZ}dSZ~dTZdUZdVZdWZej`dXZdte_eje e jeeje eIee{e~ee|e}ee:jde<ee9je< dodYZe;jeedZZd[Zd\Zd]Zdd^d_Zd`ZdaZdbZeJee edcdcee ejdcee˫Ze9jeee:jeeddZdeZeJee edfdfee ejdfUZee9je<e:jeedgZeJeeGdhee ejdhUZe9jeee:jeeeJeeGdiee ejdiUZe9jeee:jeedjZdkZdlZGdmdnZdoZeJeedpe(ee ejdpZe:jeee9jeeJeedqe(ee ejdqZe:jeee9jee;jee;je eeedsdsre;jee;je eeedsdsrdsZdtZduZeJeeGdve(ee ejdvZe:jeeee9je<eJeeGdwe(ee ejdwZe:jeeeJeeGdxe(ee ejdxZe:jeedyZe;jee eeOjFee;jee eeOjHee;jee eeOjee;jee eeOj|ee;jee eeOjJee;jee ee;jree;jee ee;jnedzZd{ZeJee e)ee:d|d|ee ejd|}Ze9jRed~e:j(edZe;jeeejVejXejVejZejVej\dZejVej`ejVejbejVejddZdZdZdddZdddZdddZdZdZe0dZdte_eje e jeejeee9je<ee:jde<dZe;jeedZdZdZe0dZdte_eje e jeejedZe;jeeee9je<ee:jde<dZdZÐee9jej<ee:jdej<ddZe0dZƐeƐje e jeƫeƐjddZe;jeƐeǫdZȐdZe0dZʐeʐje e jeʫeʐjeɫdZe;jeʐe˫dZ̐dZe0dZΐeΐje e jeΫeΐjeͫdZe;jeΐeϫdZАdZѐdZҐdZӐdZGddej ZՐdeՐ_dpdZאdZe0dZdte_eِje e je٫eِje eIeِeАeӐeԐeѐeҫe;jeِeثdqdZڐdrdZېdZܐdZݐdZej`dZߐeߐje eސe߫eߐjde;jeߐde9jReߐde:j(e߫dZGdde"jZeZe"jjee"jjeej`dZejddte_ejde;jede9jRedde:jde<ejZeՐjfdddZdZe0dZeje e jeejedZee=jVe<dZeejXe<dZe;jeeejZdZd„ZGdÄdejZdńZid=dƓd!dǓd/dȓdbdbddɓd-dʓd$d˓d&d̓d1d͓dΐdΓdϐdϓdАdГdѐdѓdFdFddd d ddid+d+dpdғddӓddd d dddԐdԓdՐdՓd֐d֓dאdדdddؐdؓdِdٓdڐdړdېdۓd d dydܓidxdݓdjdޓddߓdddddLddddd/d~dddddddddd)d)dBdBdhdddddiZdsdZdtdZdZe e dZd{eːd<dZe e dZd{eːd<dZdZe e dZd{eːd<e e ddZd{eːd<e!jVZd{ed<e!jVZd{eːd<ddZdudZdZdZdvdZdZdZdddZ ej`dZ e je e je dZ e je dZ e;je e de;je e ddZ e;je e dZee:je <dZej`dZe j"edZejedZe;jeeej`dZejd ejd e;jed d e9je<d e9je<e:j(edZdZdZej`dZdte_eje e jeejee;jeedZee:jde<dZee9je<dZee9je<y(w) annotationsN)CallableSequence)partial)Any NamedTupleTypeVarUnioncastoverload)ad_util)api)api_util)array)config)core) deprecations)dispatch)dtypes)effects)literals) linear_util)pjit)pretty_printer)source_info_util)state) tree_util)util) array_types) Primitive ShapedArrayabstract_tokencanonicalize_shape)UnexpectedTracerError) HashableArray)ad)batching)mlir) partial_eval)pxla)slicing)utils)get_abstract_meshget_concrete_mesh) input_dtypedtype_to_string#standard_multi_result_abstract_evalstandard_primitive)ir)chlo)hlo)Sharding) PmapSharding NamedSharding PartitionSpeccanonicalize_sharding flatten_spec)Array ArrayLikeDimSizeDuckTypedArrayDType DTypeLikeShape)cachecanonicalize_axissafe_mapsafe_zip split_listweakref_lru_cacheforeach tuple_insertTzjax.laxc|jdk\sJt|gt|jdz |jdz |jdz S)N)ndim transposerangexs K/home/cdr/jupyterlab/.venv/lib/python3.12/site-packages/jax/_src/lax/lax.py_matrix_transposerUWsL 1 1Baffqj)B166A:BqvvzB CCwherectj|}tj||}tj|j tj ||jSN)npiinforconcrete_dim_or_errormax_dimminmin_dimmax)valdtyperWinfos rT_clip_int_to_valid_rangerd[sE %$ ""3.# dhh S$(( ; <z@_validate_shapes.._check_static_shape..cs+Csax+zUOnly non-negative indices are allowed when broadcasting static shapes, but got shape .)r#all TypeError)shapecheckedmsgs rT_check_static_shapez-_validate_shapes.._check_static_shapeas< 'G +7+ +--2IQ 8c cN ,rV)rqrB)rI)shapesrts rT_validate_shapesrv`s - v&rVcv|st|d|Dchc] }t|}}t|dk7rt|d|g}t|D]tfdddDr|j d/Dcgc]}t j |dr|c}s|j djtfdddDr|j dt|dd jtttt|d t|Scc}wcc}w) zM Attempt to broadcast shapes, raising a TypeError if broadcasting fails. z!: At least one shape is required.rNz6: arrays must have the same number of dimensions, got c3PK|]}tj|dywrh)r same_referent)rjddss rTrlz(_try_broadcast_shapes..ws" 8A4  aA ' 8#&Nrc3PK|]}tjd|ywrhrdefinitely_equal)rjrznon_1ss rTrlz(_try_broadcast_shapes..s"Gqt$$VAY2Gr|z+ got incompatible shapes for broadcasting: , rn) rplenziproappendrrjoinmapstrtuple)namerurqranks result_shaperzr{rs @@rT_try_broadcast_shapesrksH  tf=> ??#) *%3u: *% *Z1_ tf!7$ %%, L Gb 8AB 88"Q% AaT%:%:1a%@Af A GF12JG GF1I&4& K99Sc%.@%ABC1FG G G | ' +BsD1D6"D6ct|tr|St|ttjtj fr t |dSt|tjrt ||jSt|tttjfr t tj|dSt!d|dt#|d)z:Lightweight conversion of ArrayLike input to Array output.F weak_typeTz!asarray: expected ArrayLike, got z of type rn) isinstancer<boolrZndarraygeneric_convert_element_typer TypedNdArrayrintfloatbuiltinscomplexrcoerce_to_arrayrptyperRs rTasarrayrs5 H!dBJJ 34 e 44!X**+ akk ::!c5("2"234 !7!7!:d KK 7s)DG9AN OOrVcyrYrirus rTbroadcast_shapesrsCFrVcyrYrirs rTrrs9>> jnp.broadcast_shapes((1,), (4,)) (4,) >>> jnp.broadcast_shapes((3, 1), (4,)) (3, 4) >>> jnp.broadcast_shapes((3, 1), (1, 4), (5, 1, 1)) (5, 3, 4) Error when attempting to broadcast incompatible shapes: >>> jnp.broadcast_shapes((3, 1), (4, 1)) # doctest: +IGNORE_EXCEPTION_DETAIL Traceback (most recent call last): ValueError: Incompatible shapes for broadcasting: shapes=[(3, 1), (4, 1)] .. _NumPy broadcasting: https://numpy.org/doc/stable/user/basics.broadcasting.html )_broadcast_shapes_cached_broadcast_shapes_uncachedrs rTrrs%L/ #V ,,/ %v ..s ct|SrY)rrs rTrrs #V ,,rVc.t||^}}|s|St|ttdk(stfd|DrSt fd|D} t |ddiS#t $r}tdt||d}~wwxYw)Nkeyrc3hK|])}tjt|z d|+ywrY)rdefinitely_equal_shaper)rjsrOrs rTrlz-_broadcast_shapes_uncached..s/cWXd11,tc!f}~2NPQRc/2c3JK|]}gdt|z z|yw)rNNr)rjrqrOs rTrlz-_broadcast_shapes_uncached..s*[5F$$U*;"<FF[ #rrz-Incompatible shapes for broadcasting: shapes=) rv_maxrrorrrp ValueErrorlist)rufstrstrank_promoted_shapeserrrOrs @@rTrrs6)# Sjf#&, \ $ QY#c\bcc [TZ[[^ "6 P=O PP ^ DT&\NS TZ]]^s# A.. B7BBc |^}}|s |jSt|djdk(stfd|Dr jSg}|D]}t d|jz z|jj z}d|jz z|j z}|j|j||jj|td g|S) Nc|jSrYrOas rTz%broadcast_shardings..s qvvrVrrc3K|]A}jj|jz d|jjk(CywrY)shardingspecrO)rjrrOres_avals rTrlz&broadcast_shardings..s@PDEhTAFF]^, ?PsAA rYrrrqrbroadcast_shardings) rrrOroPrrqrupdatebroadcasting_sharding_rule) avalsrr aval_listrnew_spec new_shaperOrs @@rTrrs)# <<%- .( $ QY#PINPP   ) Ja'TAFF]+ajjoo=>Hqvv &0I QXXI'(zz'8'8h'8'GIJJ $$9 FI FFrVc |SrYri)rS_s rT _identityrsaxrVc,tj|S)aElementwise negation: :math:`-x`. This function lowers directly to the `stablehlo.negate`_ operation. Args: x: input array Returns: Array of same shape and dtype as ``x``, containing the element-wise negative. Notes: For unsigned integer inputs, this function returns ``2 ** nbits - x``, where ``nbits`` is the number of bits in the integer representation. .. _stablehlo.negate: https://openxla.org/stablehlo/spec#negate )neg_pbindrRs rTnegr$ ArVc,tj|S)a<Elementwise sign. This function lowers directly to the `stablehlo.sign`_ operation. Args: x: input array Returns: Array of same shape and dtype as ``x``, containing the sign of the value, as defined in Notes below. Notes: For floating-point inputs, returns .. math:: \mathrm{sign}(x) = \begin{cases} -1 & x < 0\\ -0 & x = -0\\ \mathit{NaN} & x = \mathit{NaN}\\ +0 & x = +0\\ 1 & x > 0 \end{cases} For signed integer inputs, returns .. math:: \mathrm{sign}(x) = \begin{cases} -1 & x < 0\\ 0 & x = 0\\ 1 & x > 0 \end{cases} For complex inputs, returns the complex phase, i.e. :math:`\mathrm{sign}(x) = x / |x|`. .. _stablehlo.sign: https://openxla.org/stablehlo/spec#sign )sign_prrRs rTsignr sR QrVc`tj||\}}tj||S)a;Returns the next representable value after ``x1`` in the direction of ``x2``. This function lowers directly to the ``chlo.next_after`` operation. Args: x1, x2: input arrays. Must have a matching floating-point dtypes. If neither is a scalar, must have the same number of dimensions and be broadcast-compatible. Returns: Array of the same dtype and broadcasted shape of the inputs, containing the next representable floating-point value after ``x1`` in the direction of ``x2``. Notes: In some environments flush-denormal-to-zero semantics is used. This means that, around zero, this function returns strictly non-zero values which appear as zero in any operations. Consider this example:: >>> from jax import lax >>> lax.nextafter(0.0, 1.0) # denormal numbers are representable Array(1.e-45, dtype=float32, weak_type=True) >>> lax.nextafter(0.0, 1.0) * 1 # but are flushed to zero Array(0., dtype=float32, weak_type=True) For the smallest usable (i.e. normal) float, use ``tiny`` of ``jnp.finfo``. )rstandard_insert_pvary nextafter_prx1x2s rT nextafterr5s-8  % %b" -&"b   "b !!rVc,tj|S)aElementwise floor: :math:`\left\lfloor x \right\rfloor`. This function lowers directly to the `stablehlo.floor`_ operation. Args: x: input array. Must have floating-point type. Returns: Array of same shape and dtype as ``x``, containing values rounded to the next integer toward negative infinity. See also: - :func:`jax.lax.ceil`: round to the next integer toward positive infinity - :func:`jax.lax.round`: round to the nearest integer .. _stablehlo.floor: https://openxla.org/stablehlo/spec#floor )floor_prrRs rTfloorrTs& arVc,tj|S)aElementwise ceiling: :math:`\left\lceil x \right\rceil`. This function lowers directly to the `stablehlo.ceil`_ operation. Args: x: input array. Must have floating-point type. Returns: Array of same shape and dtype as ``x``, containing values rounded to the next integer toward positive infinity. See also: - :func:`jax.lax.floor`: round to the next integer toward negative infinity - :func:`jax.lax.round`: round to the nearest integer .. _stablehlo.ceil: https://openxla.org/stablehlo/spec#ceil )ceil_prrRs rTceilri& QrVceZdZdZdZ dZy)RoundingMethodzZRounding strategies for handling halfway values (e.g., 0.5) in :func:`jax.lax.round`. rrNN)__name__ __module__ __qualname____doc__AWAY_FROM_ZEROTO_NEAREST_EVENrirVrTrr~s.J/rVrcFt|}tj||S)aYElementwise round. Rounds values to the nearest integer. This function lowers directly to the `stablehlo.round`_ operation. Args: x: an array or scalar value to round. Must have floating-point type. rounding_method: the method to use when rounding halfway values (e.g., ``0.5``). See :class:`jax.lax.RoundingMethod` for possible values. Returns: An array of the same shape and dtype as ``x``, containing the elementwise rounding of ``x``. See also: - :func:`jax.lax.floor`: round to the next integer toward negative infinity - :func:`jax.lax.ceil`: round to the next integer toward positive infinity Examples: >>> import jax.numpy as jnp >>> from jax import lax >>> x = jnp.array([-1.5, -1.0, -0.5, 0.0, 0.5, 1.0, 1.5]) >>> jax.lax.round(x) # defaults method is AWAY_FROM_ZERO Array([-2., -1., -1., 0., 1., 1., 2.], dtype=float32) >>> jax.lax.round(x, rounding_method=jax.lax.RoundingMethod.TO_NEAREST_EVEN) Array([-2., -1., -0., 0., 0., 1., 2.], dtype=float32) .. _stablehlo.round: https://openxla.org/stablehlo/spec#round )rounding_method)rround_pr)rSrs rTroundrs"B#?3/ a 99rVc,tj|S)a9Elementwise :math:`\mathrm{isfinite}`. This function lowers directly to the `stablehlo.is_finite`_ operation. Args: x: input array. Must have floating-point type. Returns: Array of boolean dtype with the same shape as ``x``, containing ``False`` where ``x`` is :math:`\pm\infty` or :math:`\mathit{NaN}`, and ``True`` otherwise. See also: - :func:`jax.numpy.isinf`: return True where array is infinite. - :func:`jax.numpy.isnan`: return True where array is NaN. .. _stablehlo.is_finite: https://openxla.org/stablehlo/spec#is_finite ) is_finite_prrRs rT is_finiters&   ! rVceZdZdZdddZy) TolerancezSpecify the tolerances used for computing unary functions. Maximum two tolerances can be specified: (atol and rtol) or (atol and ulps). c|dks |dks|dkr td|dk(r|dk(r|dk(r td||_||_||_y)Nz Tolerances must be non-negative.rz0At least one of atol, rtol, or ulps must be set.)ratolrtolulps)selfrrrs rT__init__zTolerance.__init__sU czTCZ4#: 9 :: s{ts{tqy I JJDIDIDIrVN)rrr)rrrrrr)rrrrrrirVrTrrs  rVrceZdZdZdZy) AccuracyModerNrMN)rrrHIGHESTDEFAULTrirVrTrrs ' 'rVrc0tj||S)aElementwise exponential: :math:`e^x`. This function lowers directly to the `stablehlo.exponential`_ operation. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise exponential. See also: - :func:`jax.lax.exp2`: elementwise base-2 exponentional: :math:`2^x`. - :func:`jax.lax.log`: elementwise natural logarithm: :math:`\mathrm{log}(x)`. .. _stablehlo.exponential: https://openxla.org/stablehlo/spec#exponential accuracy)exp_prrSrs rTexprs2 A ))rVc0tj||S)a Elementwise base-2 exponential: :math:`2^x`. This function is implemented in terms of the `stablehlo.exponential`_ and `stablehlo.multiply`_ operations. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise base-2 exponential. See also: - :func:`jax.lax.exp`: elementwise exponentional: :math:`e^x`. - :func:`jax.lax.log`: elementwise natural logarithm: :math:`\mathrm{log}(x)`. .. _stablehlo.exponential: https://openxla.org/stablehlo/spec#exponential .. _stablehlo.multiply: https://openxla.org/stablehlo/spec#multiply r)exp2_prrs rTexp2r4 Q **rVc0tj||S)aElementwise :math:`e^{x} - 1`. This function lowers directly to the `stablehlo.exponential_minus_one`_ operation. Compared to the naive expression ``lax.exp(x) - 1``, it is more accurate for ``x`` near zero. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise exponential minus 1. See also: - :func:`jax.lax.exp`: elementwise exponentional: :math:`e^x`. - :func:`jax.lax.log1p`: elementwise :math:`\mathrm{log}(1 + x)`. .. _stablehlo.exponential_minus_one: https://openxla.org/stablehlo/spec#exponential_minus_one r)expm1_prrs rTexpm1r 6 a( ++rVc0tj||S)aBElementwise natural logarithm: :math:`\mathrm{log}(x)`. This function lowers directly to the `stablehlo.log`_ operation. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise natural logarithm. See also: - :func:`jax.lax.exp`: elementwise exponentional: :math:`e^x`. .. _stablehlo.log: https://openxla.org/stablehlo/spec#log r)log_prrs rTlogr.s0 A ))rVc0tj||S)aElementwise :math:`\mathrm{log}(1 + x)`. This function lowers directly to the `stablehlo.log_plus_one`_ operation. Compared to the naive expression ``lax.log(1 + x)``, it is more accurate for ``x`` near zero. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise natural logarithm of ``x + 1``. See also: - :func:`jax.lax.expm1`: elementwise :math:`e^x - 1`. - :func:`jax.lax.log`: elementwise natural logarithm :math:`\mathrm{log}(x)`. .. _stablehlo.log_plus_one: https://openxla.org/stablehlo/spec#log_plus_one r)log1p_prrs rTlog1prHr rVc0tj||S)aElementwise hyperbolic tangent: :math:`\mathrm{tanh}(x)`. This function lowers directly to the `stablehlo.tanh`_ operation. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise hyperbolic tangent. See also: - :func:`jax.lax.atanh`: elementwise inverse hyperbolic tangent. - :func:`jax.lax.cosh`: elementwise hyperbolic cosine. - :func:`jax.lax.sinh`: elementwise hyperbolic sine. .. _stablehlo.tanh: https://openxla.org/stablehlo/spec#tanh r)tanh_prrs rTtanhrer rVc0tj||S)aElementwise logistic (sigmoid) function: :math:`\frac{1}{1 + e^{-x}}`. There is no HLO logistic/sigmoid primitive, so this lowers to a sequence of HLO arithmetic operations. Args: x: input array. Must have floating point or complex dtype. Returns: Array of the same shape and dtype as ``x`` containing the element-wise logistic/sigmoid function. See also: - :func:`jax.nn.sigmoid`: an alternative API for this functionality. r) logistic_prrs rTlogisticrs$ X ..rVc0tj||S)aElementwise sine: :math:`\mathrm{sin}(x)`. For floating-point inputs, this function lowers directly to the `stablehlo.sine`_ operation. For complex inputs, it lowers to a sequence of HLO operations implementing the complex sine. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise sine. See also: - :func:`jax.lax.cos`: elementwise cosine. - :func:`jax.lax.tan`: elementwise tangent. - :func:`jax.lax.asin`: elementwise arc sine. .. _stablehlo.sine: https://openxla.org/stablehlo/spec#sine r)sin_prrs rTsinr8 A ))rVc0tj||S)aElementwise cosine: :math:`\mathrm{cos}(x)`. For floating-point inputs, this function lowers directly to the `stablehlo.cosine`_ operation. For complex inputs, it lowers to a sequence of HLO operations implementing the complex cosine. Args: x: input array. Must have floating-point or complex type. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: Array of the same shape and dtype as ``x`` containing the element-wise cosine. See also: - :func:`jax.lax.sin`: elementwise sine. - :func:`jax.lax.tan`: elementwise tangent. - :func:`jax.lax.acos`: elementwise arc cosine. .. _stablehlo.cosine: https://openxla.org/stablehlo/spec#cosine r)cos_prrs rTcosr rrVc`tj||\}}tj||S)aElementwise two-term arc tangent: :math:`\mathrm{atan}({x \over y})`. This function lowers directly to the `stablehlo.atan2`_ operation. Args: x, y: input arrays. Must have a matching floating-point or complex dtypes. If neither is a scalar, the two arrays must have the same number of dimensions and be broadcast-compatible. Returns: Array of the same shape and dtype as ``x`` and ``y`` containing the element-wise arc tangent of :math:`x \over y`, respecting the quadrant indicated by the sign of each input. See also: - :func:`jax.lax.tan`: elementwise tangent. - :func:`jax.lax.atan`: elementwise one-term arc tangent. .. _stablehlo.atan2: https://openxla.org/stablehlo/spec#atan2 )rratan2_prrSys rTatan2r%s+,  # #Aq )$!Q a rVc,tj|S)amElementwise extract real part: :math:`\mathrm{Re}(x)`. This function lowers directly to the `stablehlo.real`_ operation. Args: x: input array. Must have complex dtype. Returns: Array of the same shape as ``x`` containing its real part. Will have dtype float32 if ``x.dtype == complex64``, or float64 if ``x.dtype == complex128``. See also: - :func:`jax.lax.complex`: elementwise construct complex number. - :func:`jax.lax.imag`: elementwise extract imaginary part. - :func:`jax.lax.conj`: elementwise complex conjugate. .. _stablehlo.real: https://openxla.org/stablehlo/spec#real )real_prrRs rTrealr(( QrVc,tj|S)arElementwise extract imaginary part: :math:`\mathrm{Im}(x)`. This function lowers directly to the `stablehlo.imag`_ operation. Args: x: input array. Must have complex dtype. Returns: Array of the same shape as ``x`` containing its imaginary part. Will have dtype float32 if ``x.dtype == complex64``, or float64 if ``x.dtype == complex128``. See also: - :func:`jax.lax.complex`: elementwise construct complex number. - :func:`jax.lax.real`: elementwise extract real part. - :func:`jax.lax.conj`: elementwise complex conjugate. .. _stablehlo.imag: https://openxla.org/stablehlo/spec#imag )imag_prrRs rTimagr,r)rVc`tj||\}}tj||S)a#Elementwise make complex number: :math:`x + jy`. This function lowers directly to the `stablehlo.complex`_ operation. Args: x, y: input arrays. Must have matching floating-point dtypes. If neither is a scalar, the two arrays must have the same number of dimensions and be broadcast-compatible. Returns: The complex array with the real part given by ``x``, and the imaginary part given by ``y``. For inputs of dtype float32 or float64, the result will have dtype complex64 or complex128 respectively. See also: - :func:`jax.lax.real`: elementwise extract real part. - :func:`jax.lax.imag`: elementwise extract imaginary part. - :func:`jax.lax.conj`: elementwise complex conjugate. .. _stablehlo.complex: https://openxla.org/stablehlo/spec#complex )rr complex_prr#s rTrrs+.  # #Aq )$!Q 1 rVcBtj|t|S)aElementwise complex conjugate function: :math:`\overline{x}`. This function lowers to a combination of `stablehlo.real`_, `stablehlo.imag`_, and `stablehlo.complex`_. Args: x: input array. Must have complex dtype. Returns: Array of the same shape and dtype as ``x`` containing its complex conjugate. See also: - :func:`jax.lax.complex`: elementwise construct complex number. - :func:`jax.lax.real`: elementwise extract real part. - :func:`jax.lax.imag`: elementwise extract imaginary part. - :func:`jax.lax.abs`: elementwise absolute value / complex magnitude. .. _stablehlo.real: https://openxla.org/stablehlo/spec#real .. _stablehlo.imag: https://openxla.org/stablehlo/spec#imag .. _stablehlo.complex: https://openxla.org/stablehlo/spec#complex )r/)conj_pr_dtyperRs rTconjr20s0 QF1I ..rVc,tj|S)aElementwise absolute value: :math:`|x|`. This function lowers directly to the `stablehlo.abs`_ operation. Args: x: Input array. Must have signed integer, floating, or complex dtype. Returns: An array of the same shape as ``x`` containing the elementwise absolute value. For complex valued input, :math:`a + ib`, ``abs(x)`` returns :math:`\sqrt{a^2+b^2}`. See also: - :func:`jax.numpy.abs`: a more flexible NumPy-style ``abs`` implementation. .. _stablehlo.abs: https://openxla.org/stablehlo/spec#abs )abs_prrRs rTabsr5JrrVc`tj||\}}tj||S)alElementwise power: :math:`x^y`. This function lowers directly to the `stablehlo.pow`_ operation, along with a `stablehlo.convert`_ when the argument dtypes do not match. Args: x: Input array giving the base value. Must have floating or complex type. y: Input array giving the exponent value. Must have integer, floating, or complex type. Its dtype will be cast to that of ``x.dtype`` if necessary. If neither ``x`` nor ``y`` is a scalar, then ``x`` and ``y`` must have the same number of dimensions and be broadcast-compatible. Returns: An array of the same dtype as ``x`` containing the elementwise power. See also: :func:`jax.lax.integer_pow`: Elementwise power where ``y`` is a static integer. .. _stablehlo.convert: https://openxla.org/stablehlo/spec#convert .. _stablehlo.pow: https://openxla.org/stablehlo/spec#pow )rrpow_prr#s rTpowr8^+.  # #Aq )$!Q Aq rVc0tj||S)a Elementwise power: :math:`x^y`, where :math:`y` is a static integer. This will lower to a sequence of :math:`O[\log_2(y)]` repetitions of `stablehlo.multiply`_. Args: x: Input array giving the base value. Must have numerical dtype. y: Static scalar integer giving the exponent. Returns: An array of the same shape and dtype as ``x`` containing the elementwise power. See also: :func:`jax.lax.pow`: Elementwise power where ``y`` is an array. .. _stablehlo.multiply: https://openxla.org/stablehlo/spec#multiply r$) integer_pow_prr#s rT integer_powr=xs&   A  ##rVc0tj||S)axElementwise square root: :math:`\sqrt{x}`. This function lowers directly to the `stablehlo.sqrt`_ operation. Args: x: Input array. Must have floating or complex dtype. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: An array of the same shape and dtype as ``x`` containing the square root. See also: :func:`jax.lax.pow`: Elementwise power. :func:`jax.lax.cbrt`: Elementwise cube root. :func:`jax.lax.rsqrt`: Elementwise reciporical square root. .. _stablehlo.sqrt: https://openxla.org/stablehlo/spec#sqrt r)sqrt_prrs rTsqrtr@2 Q **rVc0tj||S)aElementwise reciprocal square root: :math:`1 \over \sqrt{x}`. This function lowers directly to the `stablehlo.rsqrt`_ operation. Args: x: Input array. Must have floating or complex dtype. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: An array of the same shape and dtype as ``x`` containing the reciporical square root. See also: :func:`jax.lax.pow`: Elementwise power. :func:`jax.lax.sqrt`: Elementwise square root. :func:`jax.lax.cbrt`: Elementwise cube root. .. _stablehlo.rsqrt: https://openxla.org/stablehlo/spec#rsqrt r)rsqrt_prrs rTrsqrtrDs4 a( ++rVc0tj||S)ayElementwise cube root: :math:`\sqrt[3]{x}`. This function lowers directly to the `stablehlo.cbrt`_ operation. Args: x: Input array. Must have floating or complex dtype. accuracy: Optional `lax.Tolerance` or `lax.AccuracyMode` object that selects the implementation of the op based on the requested accuracy. If the implementation cannot satisfy the requested tolerance, the compiler will return an error. If mode is specified and there are no multiple implementations available, the default implementation will be used. Returns: An array of the same shape and dtype as ``x`` containing the cube root. See also: :func:`jax.lax.pow`: Elementwise power. :func:`jax.lax.sqrt`: Elementwise square root. :func:`jax.lax.rsqrt`: Elementwise reciporical square root. .. _stablehlo.cbrt: https://openxla.org/stablehlo/spec#cbrt r)cbrt_prrs rTcbrtrGrArVc,tj|S)aElementwise NOT: :math:`\neg x`. This function lowers directly to the `stablehlo.not`_ operation. Args: x: Input array. Must have boolean or integer dtype. Returns: An array of the same shape and dtype as ``x`` containing the bitwise inversion of each entry. See also: - :func:`jax.numpy.invert`: NumPy wrapper for this API, also accessible via the ``~x`` operator on JAX arrays. - :func:`jax.lax.bitwise_and`: Elementwise AND. - :func:`jax.lax.bitwise_or`: Elementwise OR. - :func:`jax.lax.bitwise_xor`: Elementwise exclusive OR. .. _stablehlo.not: https://openxla.org/stablehlo/spec#not )not_prrRs rT bitwise_notrJs, ArVc`tj||\}}tj||S)a#Elementwise AND: :math:`x \wedge y`. This function lowers directly to the `stablehlo.and`_ operation. Args: x, y: Input arrays. Must have matching boolean or integer dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the bitwise AND of each pair of broadcasted entries. See also: - :func:`jax.numpy.bitwise_and`: NumPy wrapper for this API, also accessible via the ``x & y`` operator on JAX arrays. - :func:`jax.lax.bitwise_not`: Elementwise NOT. - :func:`jax.lax.bitwise_or`: Elementwise OR. - :func:`jax.lax.bitwise_xor`: Elementwise exclusive OR. .. _stablehlo.and: https://openxla.org/stablehlo/spec#and )rrand_prr#s rT bitwise_andrM+0  # #Aq )$!Q Aq rVc`tj||\}}tj||S)aElementwise OR: :math:`x \vee y`. This function lowers directly to the `stablehlo.or`_ operation. Args: x, y: Input arrays. Must have matching boolean or integer dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the bitwise OR of each pair of broadcasted entries. See also: - :func:`jax.numpy.invert`: NumPy wrapper for this API, also accessible via the ``x | y`` operator on JAX arrays. - :func:`jax.lax.bitwise_not`: Elementwise NOT. - :func:`jax.lax.bitwise_and`: Elementwise AND. - :func:`jax.lax.bitwise_xor`: Elementwise exclusive OR. .. _stablehlo.or: https://openxla.org/stablehlo/spec#or )rror_prr#s rT bitwise_orrQs*0  # #Aq )$!Q 1arVc`tj||\}}tj||S)a#Elementwise exclusive OR: :math:`x \oplus y`. This function lowers directly to the `stablehlo.xor`_ operation. Args: x, y: Input arrays. Must have matching boolean or integer dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the bitwise XOR of each pair of broadcasted entries. See also: - :func:`jax.numpy.bitwise_xor`: NumPy wrapper for this API, also accessible via the ``x ^ y`` operator on JAX arrays. - :func:`jax.lax.bitwise_not`: Elementwise NOT. - :func:`jax.lax.bitwise_and`: Elementwise AND. - :func:`jax.lax.bitwise_or`: Elementwise OR. .. _stablehlo.xor: https://openxla.org/stablehlo/spec#xor )rrxor_prr#s rT bitwise_xorrT.rNrVc,tj|S)aElementwise popcount, count the number of set bits in each element. This function lowers directly to the `stablehlo.popcnt`_ operation. Args: x: Input array. Must have integer dtype. Returns: An array of the same shape and dtype as ``x``, containing the number of set bits in the input. See also: - :func:`jax.lax.clz`: Elementwise count leading zeros. - :func:`jax.numpy.bitwise_count`: More flexible NumPy-style API for bit counts. .. _stablehlo.popcnt: https://openxla.org/stablehlo/spec#popcnt )population_count_prrRs rTpopulation_countrWIs&   ##rVc,tj|S)aElementwise count-leading-zeros. This function lowers directly to the `stablehlo.count_leading_zeros`_ operation. Args: x: Input array. Must have integer dtype. Returns: An array of the same shape and dtype as ``x``, containing the number of set bits in the input. See also: - :func:`jax.lax.population_count`: Count the number of set bits in each element. .. _stablehlo.count_leading_zeros: https://openxla.org/stablehlo/spec#count_leading_zeros )clz_prrRs rTclzrZ^rrVc`tj||\}}tj||S)aUElementwise addition: :math:`x + y`. This function lowers directly to the `stablehlo.add`_ operation. Args: x, y: Input arrays. Must have matching numerical dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the sum of each pair of broadcasted entries. See also: - :func:`jax.numpy.add`: NumPy-style addition supporting inputs with mixed dtypes and ranks. .. _stablehlo.add: https://openxla.org/stablehlo/spec#add )rradd_prr#s rTaddr]r+*  # #Aq )$!Q Aq rVc`tj||\}}tj||S)avElementwise subtraction: :math:`x - y`. This function lowers directly to the `stablehlo.subtract`_ operation. Args: x, y: Input arrays. Must have matching numerical dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the difference of each pair of broadcasted entries. See also: - :func:`jax.numpy.subtract`: NumPy-style subtraction supporting inputs with mixed dtypes and ranks. .. _stablehlo.subtract: https://openxla.org/stablehlo/spec#subtract )rrsub_prr#s rTsubrar^rVc`tj||\}}tj||S)a~Elementwise multiplication: :math:`x \times y`. This function lowers directly to the `stablehlo.multiply`_ operation. Args: x, y: Input arrays. Must have matching numerical dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the product of each pair of broadcasted entries. See also: - :func:`jax.numpy.multiply`: NumPy-style multiplication supporting inputs with mixed dtypes and ranks. .. _stablehlo.multiply: https://openxla.org/stablehlo/spec#multiply )rrmul_prr#s rTmulrdr^rVc`tj||\}}tj||S)aElementwise division: :math:`x \over y`. This function lowers directly to the `stablehlo.divide`_ operation. Integer division overflow (division by zero or signed division of INT_SMIN with -1) produces an implementation defined value. Args: x, y: Input arrays. Must have matching numerical dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the quotient of each pair of broadcasted entries. For integer inputs, any fractional part is discarded. See also: - :func:`jax.numpy.divide`: NumPy-style true division supporting inputs with mixed dtypes and ranks. - :func:`jax.numpy.floor_divide`: NumPy-style floor division supporting inputs with mixed dtypes and ranks. .. _stablehlo.divide: https://openxla.org/stablehlo/spec#divide )rrdiv_prr#s rTdivrgs+6  # #Aq )$!Q Aq rVc`tj||\}}tj||S)aPElementwise remainder: :math:`x \bmod y`. This function lowers directly to the `stablehlo.remainder`_ operation. The sign of the result is taken from the dividend, and the absolute value of the result is always less than the divisor's absolute value. Integer division overflow (remainder by zero or remainder of INT_SMIN with -1) produces an implementation defined value. Args: x, y: Input arrays. Must have matching int or float dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the remainder. See also: - :func:`jax.numpy.remainder`: NumPy-style remainder with different sign semantics. .. _stablehlo.remainder: https://openxla.org/stablehlo/spec#remainder )rrrem_prr#s rTremrjs+2  # #Aq )$!Q Aq rVc`tj||\}}tj||S)aElementwise maximum: :math:`\mathrm{max}(x, y)`. This function lowers directly to the `stablehlo.maximum`_ operation for non-complex inputs. For complex numbers, this uses a lexicographic comparison on the `(real, imaginary)` pairs. Args: x, y: Input arrays. Must have matching dtypes. If neither is a scalar, ``x`` and ``y`` must have the same rank and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the elementwise maximum. See also: - :func:`jax.numpy.maximum`: more flexibly NumPy-style maximum. - :func:`jax.lax.reduce_max`: maximum along an axis of an array. - :func:`jax.lax.min`: elementwise minimum. .. _stablehlo.maximum: https://openxla.org/stablehlo/spec#maximum )rrmax_prr#s rTr`r`r9rVc`tj||\}}tj||S)aElementwise minimum: :math:`\mathrm{min}(x, y)` This function lowers directly to the `stablehlo.minimum`_ operation for non-complex inputs. For complex numbers, this uses a lexicographic comparison on the `(real, imaginary)` pairs. Args: x, y: Input arrays. Must have matching dtypes. If neither is a scalar, ``x`` and ``y`` must have the same rank and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the elementwise minimum. See also: - :func:`jax.numpy.minimum`: more flexibly NumPy-style minimum. - :func:`jax.lax.reduce_min`: minimum along an axis of an array. - :func:`jax.lax.max`: elementwise maximum. .. _stablehlo.minimum: https://openxla.org/stablehlo/spec#minimum )rrmin_prr#s rTr^r^r9rVc`tj||\}}tj||S)a8Elementwise left shift: :math:`x \ll y`. This function lowers directly to the `stablehlo.shift_left`_ operation. Args: x, y: Input arrays. Must have matching integer dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the element-wise left shift of each pair of broadcasted entries. See also: - :func:`jax.numpy.left_shift`: NumPy wrapper for this API, also accessible via the ``x << y`` operator on JAX arrays. - :func:`jax.lax.shift_right_arithmetic`: Elementwise arithmetic right shift. - :func:`jax.lax.shift_right_logical`: Elementwise logical right shift. .. _stablehlo.shift_left: https://openxla.org/stablehlo/spec#shift_left )rr shift_left_prr#s rT shift_leftrq(s-.  # #Aq )$!Q   1a  rVc`tj||\}}tj||S)aElementwise arithmetic right shift: :math:`x \gg y`. This function lowers directly to the `stablehlo.shift_right_arithmetic`_ operation. Args: x, y: Input arrays. Must have matching integer dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the element-wise arithmetic right shift of each pair of broadcasted entries. See also: - :func:`jax.numpy.right_shift`: NumPy wrapper for this API when applied to signed integers, also accessible via the ``x >> y`` operator on JAX arrays with signed integer dtype. - :func:`jax.lax.shift_left`: Elementwise left shift. - :func:`jax.lax.shift_right_logical`: Elementwise logical right shift. .. _stablehlo.shift_right_arithmetic: https://openxla.org/stablehlo/spec#shift_right_arithmetic )rrshift_right_arithmetic_prr#s rTshift_right_arithmeticrtBs-0  # #Aq )$!Q ! & &q! ,,rVc`tj||\}}tj||S)aElementwise logical right shift: :math:`x \gg y`. This function lowers directly to the `stablehlo.shift_right_logical`_ operation. Args: x, y: Input arrays. Must have matching integer dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: An array of the same dtype as ``x`` and ``y`` containing the element-wise logical right shift of each pair of broadcasted entries. See also: - :func:`jax.numpy.right_shift`: NumPy wrapper for this API when applied to unsigned integers, also accessible via the ``x >> y`` operator on JAX arrays with unsigned integer dtype. - :func:`jax.lax.shift_left`: Elementwise left shift. - :func:`jax.lax.shift_right_arithmetic`: Elementwise arithmetic right shift. .. _stablehlo.shift_right_logical: https://openxla.org/stablehlo/spec#shift_right_logical )rrshift_right_logical_prr#s rTshift_right_logicalrw]s-0  # #Aq )$!Q  # #Aq ))rVc`tj||\}}tj||S)aElementwise equals: :math:`x = y`. This function lowers directly to the `stablehlo.compare`_ operation with ``comparison_direction=EQ`` and ``compare_type`` set according to the input dtype. Args: x, y: Input arrays. Must have matching dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: A boolean array of shape ``lax.broadcast_shapes(x.shape, y.shape)`` containing the elementwise equal comparison. See also: - :func:`jax.numpy.equal`: NumPy wrapper for this API, also accessible via the ``x == y`` operator on JAX arrays. - :func:`jax.lax.ne`: elementwise not-equal - :func:`jax.lax.ge`: elementwise greater-than-or-equal - :func:`jax.lax.gt`: elementwise greater-than - :func:`jax.lax.le`: elementwise less-than-or-equal - :func:`jax.lax.lt`: elementwise less-than .. _stablehlo.compare: https://openxla.org/stablehlo/spec#compare )rreq_prr#s rTeqrzx*8  # #Aq )$!Q 1arVc`tj||\}}tj||S)aElementwise not-equals: :math:`x \neq y`. This function lowers directly to the `stablehlo.compare`_ operation with ``comparison_direction=NE`` and ``compare_type`` set according to the input dtype. Args: x, y: Input arrays. Must have matching dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: A boolean array of shape ``lax.broadcast_shapes(x.shape, y.shape)`` containing the elementwise not-equal comparison. See also: - :func:`jax.numpy.not_equal`: NumPy wrapper for this API, also accessible via the ``x != y`` operator on JAX arrays. - :func:`jax.lax.eq`: elementwise equal - :func:`jax.lax.ge`: elementwise greater-than-or-equal - :func:`jax.lax.gt`: elementwise greater-than - :func:`jax.lax.le`: elementwise less-than-or-equal - :func:`jax.lax.lt`: elementwise less-than .. _stablehlo.compare: https://openxla.org/stablehlo/spec#compare )rrne_prr#s rTner~r{rVc`tj||\}}tj||S)aElementwise greater-than-or-equals: :math:`x \geq y`. This function lowers directly to the `stablehlo.compare`_ operation with ``comparison_direction=GE`` and ``compare_type`` set according to the input dtype. Args: x, y: Input arrays. Must have matching non-complex dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: A boolean array of shape ``lax.broadcast_shapes(x.shape, y.shape)`` containing the elementwise greater-than-or-equal comparison. See also: - :func:`jax.numpy.greater_equal`: NumPy wrapper for this API, also accessible via the ``x >= y`` operator on JAX arrays. - :func:`jax.lax.eq`: elementwise equal - :func:`jax.lax.ne`: elementwise not-equal - :func:`jax.lax.gt`: elementwise greater-than - :func:`jax.lax.le`: elementwise less-than-or-equal - :func:`jax.lax.lt`: elementwise less-than .. _stablehlo.compare: https://openxla.org/stablehlo/spec#compare )rrge_prr#s rTgerr{rVc`tj||\}}tj||S)aElementwise greater-than: :math:`x > y`. This function lowers directly to the `stablehlo.compare`_ operation with ``comparison_direction=GT`` and ``compare_type`` set according to the input dtype. Args: x, y: Input arrays. Must have matching non-complex dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: A boolean array of shape ``lax.broadcast_shapes(x.shape, y.shape)`` containing the elementwise greater-than comparison. See also: - :func:`jax.numpy.greater`: NumPy wrapper for this API, also accessible via the ``x > y`` operator on JAX arrays. - :func:`jax.lax.eq`: elementwise equal - :func:`jax.lax.ne`: elementwise not-equal - :func:`jax.lax.ge`: elementwise greater-than-or-equal - :func:`jax.lax.le`: elementwise less-than-or-equal - :func:`jax.lax.lt`: elementwise less-than .. _stablehlo.compare: https://openxla.org/stablehlo/spec#compare )rrgt_prr#s rTgtrr{rVc`tj||\}}tj||S)aElementwise less-than-or-equals: :math:`x \leq y`. This function lowers directly to the `stablehlo.compare`_ operation with ``comparison_direction=LE`` and ``compare_type`` set according to the input dtype. Args: x, y: Input arrays. Must have matching non-complex dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: A boolean array of shape ``lax.broadcast_shapes(x.shape, y.shape)`` containing the elementwise less-than-or-equal comparison. See also: - :func:`jax.numpy.less_equal`: NumPy wrapper for this API, also accessible via the ``x <= y`` operator on JAX arrays. - :func:`jax.lax.eq`: elementwise equal - :func:`jax.lax.ne`: elementwise not-equal - :func:`jax.lax.ge`: elementwise greater-than-or-equal - :func:`jax.lax.gt`: elementwise greater-than - :func:`jax.lax.lt`: elementwise less-than .. _stablehlo.compare: https://openxla.org/stablehlo/spec#compare )rrle_prr#s rTlerr{rVc`tj||\}}tj||S)aElementwise less-than: :math:`x < y`. This function lowers directly to the `stablehlo.compare`_ operation with ``comparison_direction=LT`` and ``compare_type`` set according to the input dtype. Args: x, y: Input arrays. Must have matching non-complex dtypes. If neither is a scalar, ``x`` and ``y`` must have the same number of dimensions and be broadcast compatible. Returns: A boolean array of shape ``lax.broadcast_shapes(x.shape, y.shape)`` containing the elementwise less-than comparison. See also: - :func:`jax.numpy.less`: NumPy wrapper for this API, also accessible via the ``x < y`` operator on JAX arrays. - :func:`jax.lax.eq`: elementwise equal - :func:`jax.lax.ne`: elementwise not-equal - :func:`jax.lax.ge`: elementwise greater-than-or-equal - :func:`jax.lax.gt`: elementwise greater-than - :func:`jax.lax.le`: elementwise less-than-or-equal .. _stablehlo.compare: https://openxla.org/stablehlo/spec#compare )rrlt_prr#s rTltrr{rVcJtj|d}t||dS)aElementwise cast. This function lowers directly to the `stablehlo.convert`_ operation, which performs an elementwise conversion from one type to another, similar to a C++ ``static_cast``. Args: operand: an array or scalar value to be cast. new_dtype: a dtype-like object (e.g. a :class:`numpy.dtype`, a scalar type, or a valid dtype name) representing the target dtype. Returns: An array with the same shape as ``operand``, cast elementwise to ``new_dtype``. .. note:: If ``new_dtype`` is a 64-bit type and `x64 mode`_ is not enabled, the appropriate 32-bit type will be used in its place. If the input is a JAX array and the input dtype and output dtype match, then the input array will be returned unmodified. See also: - :func:`jax.numpy.astype`: NumPy-style dtype casting API. - :meth:`jax.Array.astype`: dtype casting as an array method. - :func:`jax.lax.bitcast_convert_type`: cast bits directly to a new dtype. .. _stablehlo.convert: https://openxla.org/stablehlo/spec#convert .. _x64 mode: https://docs.jax.dev/en/latest/notebooks/Common_Gotchas_in_JAX.html#double-64bit-precision convert_element_typeFr)r!check_and_canonicalize_user_dtyperoperand new_dtypes rTrr2s*B66')) w U CCrVFTrct|dr|j}tj|}t |tj st |tj rh||k(r9||St |t jr|jj|k(r|S||rtt |tj rt |tj rt j|j}t j|j}tdt|dt|dt|dt|dt|dt| t |tj rtj||St j|t#j|Stj$|}||}nt |t&sJ||t |t(std|d |rztj*|t"j,rVtj*|t"j,s2d } t/j0| t"j2j4d t7|t8urK|tj:k7r8t=j>t#j@|jC||}||f||fk(r_t |tDrOt |t jrt jF|s ||jHrtK|d d|k(r|StLj||tO||S)N __jax_array__z6cannot directly convert between extended dtypes: from  to zB. Instead, convert to and from their representation dtypes, e.g.: z -> edtyperbz sharding=z- must be an instance of jax.sharding.Shardingz:Casting complex values to real discards the imaginary partrM stacklevelrrrr)(hasattrrrrbr ExtendedDTyperTraceravalrNotImplementedErrorphysical_element_avalrr0 to_edtype_pr from_edtype_prZis_weakly_typedr@r6 issubdtypecomplexfloatingwarningswarn exceptionsComplexWarningrrfloat0rrrastyper< is_concrete _is_concretegetattrconvert_element_type_pr) rrrrwarn_on_complex_to_real_cast old_dtype old_rep_dtype new_rep_dtype old_weak_typerss rTrrWs  Wo&##%Gll7#)F001F001I   GT[[ )gll.C.Cx.Oy 9f2239f22300;AAm00;AAm  B Y ' (_Y-G,HIN Y ' (_]-K,LM ./tOI4N3O  Q RR)V112   gi  88   gRXXi-@  AA((1-I i '22 ' *Xx"@  {"OP QQ"  2#5#56   Ir'9'9 : FC MM#r}}33B ']ci6==8##BJJw$7$>$>y$I)24G- Y $::% gt{{ +0@0@0I'':t"D"P N ! & &9Y ' rVc\tj|d}tj||S)aCElementwise bitcast. This function lowers directly to the `stablehlo.bitcast_convert`_ operation. The output shape depends on the size of the input and output dtypes with the following logic:: if new_dtype.itemsize == operand.dtype.itemsize: output_shape = operand.shape if new_dtype.itemsize < operand.dtype.itemsize: output_shape = (*operand.shape, operand.dtype.itemsize // new_dtype.itemsize) if new_dtype.itemsize > operand.dtype.itemsize: assert operand.shape[-1] * operand.dtype.itemsize == new_dtype.itemsize output_shape = operand.shape[:-1] Args: operand: an array or scalar value to be cast new_dtype: the new type. Should be a NumPy type. Returns: An array of shape `output_shape` (see above) and type `new_dtype`, constructed from the same bits as operand. See also: - :func:`jax.lax.convert_element_type`: value-preserving dtype conversion. - :func:`jax.Array.view`: NumPy-style API for bitcast type conversion. .. _stablehlo.bitcast_convert: https://openxla.org/stablehlo/spec#bitcast_convert bitcast_convert_type)r)rrbitcast_convert_type_prrs rTrrs0>66'))  $ $W $ BBrVr^r`cftj|||\}}}tj|||S)zElementwise clamp. Returns :math:`\mathrm{clamp}(x) = \begin{cases} \mathit{min} & \text{if } x < \mathit{min},\\ \mathit{max} & \text{if } x > \mathit{max},\\ x & \text{otherwise} \end{cases}`. )rrclamp_pr)r^rSr`s rTclamprs1**337+#q# c1c ""rVrc.tjtj|||\}}t j ||\}}} t d| Drtd|dt jt j|} | | |fS)N debug_infoc3PK|]}t|tj ywrYrrrrjcs rTrlz,_trace_composite_to_jaxpr..4At{{ #4$&zLFound a JAX Tracer as a constant in the decomposition for the composite op 'z'. This means that the decomposition function closes over a value that is involved in a JAX transformation. Any values that aren't explicitly known at compile time must be explicitly passed as arguments to the composite.) rflatten_fun_nokwargslu wrap_initpetrace_to_jaxpr_dynamicanyr$ close_jaxprconvert_constvars_jaxpr) funin_treein_avalsrrflat_funout_treejaxprrconsts closed_jaxprs rT_trace_composite_to_jaxprrs  44ll3:.9(H..xB%F4V44  ; ; <<  : :5 AB, vx ''rVcJtjfd}|S)aU Composite with semantics defined by the decomposition function. A composite is a higher-order JAX function that encapsulates an operation made up (composed) of other JAX functions. The semantics of the op are implemented by the ``decomposition`` function. In other words, the defined composite function can be replaced with its decomposed implementation without changing the semantics of the encapsulated operation. The compiler can recognize specific composite operations by their ``name``, ``version``, ``kwargs``, and dtypes to emit more efficient code, potentially leveraging hardware-specific instructions or optimizations. If the compiler doesn't recognize the composite, it falls back to compiling the ``decomposition`` function. Consider a "tangent" composite operation. Its ``decomposition`` function could be implemented as ``sin(x) / cos(x)``. A hardware-aware compiler could recognize the "tangent" composite and emit a single ``tangent`` instruction instead of three separate instructions (``sin``, ``divide``, and ``cos``). For hardware without dedicated tangent support, it would fall back to compiling the decomposition. This is useful for preserving high-level abstractions that would otherwise be lost while lowering, which allows for easier pattern-matching in low-level IR. Args: decomposition: function that implements the semantics of the composite op. name: name of the encapsulated operation. version: optional int to indicate semantic changes to the composite. Returns: Callable: Returns a composite function. Note that positional arguments to this function should be interpreted as inputs and keyword arguments should be interpreted as attributes of the op. Any keyword arguments that are passed with ``None`` as a value will be omitted from the ``composite_attributes``. Examples: Tangent kernel: >>> def my_tangent_composite(x): ... return lax.composite( ... lambda x: lax.sin(x) / lax.cos(x), name="my.tangent" ... )(x) >>> >>> pi = jnp.pi >>> x = jnp.array([0.0, pi / 4, 3 * pi / 4, pi]) >>> with jnp.printoptions(precision=3, suppress=True): ... print(my_tangent_composite(x)) ... print(lax.tan(x)) [ 0. 1. -1. 0.] [ 0. 1. -1. 0.] The recommended way to create composites is via a decorator. Use ``/`` and ``*`` in the function signature to be explicit about positional and keyword arguments, respectively: >>> @partial(lax.composite, name="my.softmax") ... def my_softmax_composite(x, /, *, axis): ... return jax.nn.softmax(x, axis) cvtjd|i}tj|\}}t d|D}t d|j Drtddttfi||||\}}}g} |jD]C\} } tj| \} } t d| D} | j| | | fEtjg||}tj|t | |d}tj ||S)N compositec3FK|]}tj|ywrY)rget_avalrjrSs rTrlz0composite.._decorator..'s9!T]]1%9!c3PK|]}t|tj ywrYrrjvs rTrlz0composite.._decorator..(s ?!:a % ?rzNFound a JAX Tracer as an attribute in the decomposition for the composite op 'a*'. This means that the decomposition function closes over a value that is involved in a JAX transformation. Any values that aren't explicitly known at compile time must be explicitly passed as arguments to the composite. Note: If you are passing jax arrays as attributes, use numpy arrays instead.c3jK|]+}t|tjr t|n|-ywrY)rrZrr%rs rTrlz0composite.._decorator..7s,CDjBJJ7- Q >s13)r attributesversionr)rrr tree_flattenrrvaluesr$rritemsrrr composite_prtree_unflatten)argskwargsr flat_argsrrrrrrkrleavestreedefflat_consts_and_argsout_flat decompositionrrs rT _decoratorzcomposite.._decorator"sV$$[-%)2/J"//5Iw9y99H ?v}} ?? ! &!  &? (('8T:&"L&(J .1!..q1ofgHNfFG,- .  55JvJ J  $ H  # #HJ 99rV) functoolswraps)rrrrs``` rTrrs*B ??=! :" :D rVc \tj|j}tj|\}}t fd|D} g|j } tj||jt|| jj\} } } i} |D]2\}}}|j|}|tj|| |<4| jj }t#j$| j&j(tj*| |zt,j.j1|t,j2j1|t,j4j1| tj6|}|j(S)aMakes composite which calls the implementation function. Lowering a composite primitive to a ``stablehlo.composite`` op. Args: ctx: The MLIR context. *args: The arguments to the composite. name: The name of the composite. attributes: The attributes of the composite. version: The version of the composite. jaxpr: The jaxpr of the underlying composite. Returns: The results of the composite. c3hK|])\}}tj|j|+yw))const_loweringrN)r( ir_constantr)rjrrctxs rTrlz&_composite_lowering..as5 !T q););$GGr)rrcomposite_attributesr)rjaxpr_const_argsrrunzip2ravals_inr(lower_called_computationmodule_contextr avals_out tokens_in unflatten ir_attributervaluer5 CompositeOprresultsflatten_ir_valuesr3 StringAttrgetFlatSymbolRefAttrDictAttri32_attr)rrrrrrconst_args_and_avals const_args const_avalsconst_arg_valuesrfunc_oprcomposite_attrsrrrr symbol_namers` rT_composite_loweringrHso...u{{; KK(<=*k)+{ *S\\ *(//    *o mm mm-'1a/&0a&!A},,Q/oa0 ""+oo ll -45 ==  T "((,,[9;;???;mmG$ )   rVc2tj||SrY)r jaxpr_as_funrrrs rT_composite_implrs !  5 !4 ((rVc~|jSrY) out_avalsrs rT_composite_abstract_evalrs rVc~td)NzJVP rule for composite not implemented. You can use `jax.custom_jvp` to add support. See https://docs.jax.dev/en/latest/_autosummary/jax.custom_jvp.htmlrrrs rT composite_jvpr H rVc~td)NzTranspose rule for composite not implemented. You can use`jax.custom_jvp` or `jax.custom_vjp` to add support. See https://docs.jax.dev/en/latest/_autosummary/jax.custom_jvp.htmlrrs rTcomposite_transposerrrVrct|dk(r tdt|dk(r|\}t|tr|St j |}t j|d|iS)aConcatenates a sequence of arrays along `dimension`. Wraps XLA's `Concatenate `_ operator. Args: operands: a sequence of arrays to concatenate. The arrays must have equal shapes, except in the `dimension` axis. dimension: the dimension along which to concatenate the arrays. Returns: An array containing the concatenation. rz4concatenate requires a non-empty sequences of arraysrN dimension)rrrr<rr concatenate_pr)operandsr!ops rT concatenater%sd ]a K LL]a CB"e i  ' ' 2(   X ; ;;rVct|}tj|t|t ||j S)aSplits an array along ``axis``. Args: operand: an array to split sizes: the sizes of the split arrays. The sum of the sizes must be equal to the size of the ``axis`` dimension of ``operand``. axis: the axis along which to split the array. Returns: A sequence of ``len(sizes)`` arrays. If ``sizes`` is ``[s1, s2, ...]``, this function returns chunks of sizes ``s1``, ``s2``, taken along ``axis``. sizesaxis)rsplit_prrrDrOrr(r)s rTsplitr,s< G ' gU5\,T7<<@  BBrVzdict[Any, Precision]_precision_stringsc>eZdZdZdZdZdZed dZd dZ d dZ y) PrecisionaPrecision enum for lax matrix multiply related functions. The device-dependent `precision` argument to JAX functions generally controls the tradeoff between speed and accuracy for array computations on accelerator backends, (i.e. TPU and GPU). Has no impact on CPU backends. This only has an effect on float32 computations, and does not affect the input/output datatypes. Members are: DEFAULT: Fastest mode, but least accurate. On TPU: performs float32 computations in bfloat16. On GPU: uses tensorfloat32 if available (e.g. on A100 and H100 GPUs), otherwise standard float32 (e.g. on V100 GPUs). Aliases: ``'default'``, ``'fastest'``. HIGH: Slower but more accurate. On TPU: performs float32 computations in 3 bfloat16 passes. On GPU: uses tensorfloat32 where available, otherwise float32. Aliases: ``'high'``.. HIGHEST: Slowest but most accurate. On TPU: performs float32 computations in 6 bfloat16. Aliases: ``'highest'``. On GPU: uses float32. rrNrMc,tj|SrY)r-r)clsrs rT _missing_zPrecision._missing_s  ! !% ((rVcL|jjd|jSNrn __class__rrrs rT__repr__zPrecision.__repr__"nn%% &a { 33rVc|jSrYrr7s rT__str__zPrecision.__str__ 99rVN)robjectreturnzPrecision | Noner?r) rrrrrHIGHr classmethodr2r8r<rirVrTr/r/s4, ' $ '))4rVr/highestfloat32high bfloat16_3x tensorfloat32defaultbfloat16fastestcxeZdZUdZded<ded<ded<dZded<dZded <dZded <d Zd ed < ddZ y) DotAlgorithma Specify the algorithm used for computing dot products. When used to specify the ``precision`` input to :func:`~jax.lax.dot`, :func:`~jax.lax.dot_general`, and other dot product functions, this data structure is used for controlling the properties of the algorithm used for computing the dot product. This API controls the precision used for the computation, and allows users to access hardware-specific accelerations. Support for these algorithms is platform dependent, and using an unsupported algorithm will raise a Python exception when the computation is compiled. The algorithms that are known to be supported on at least some platforms are listed in the :class:`~jax.lax.DotAlgorithmPreset` enum, and these are a good starting point for experimenting with this API. A "dot algorithm" is specified by the following parameters: * ``lhs_precision_type`` and ``rhs_precision_type``, the data types that the LHS and RHS of the operation are rounded to. * ``accumulation_type`` the data type used for accumulation. * ``lhs_component_count``, ``rhs_component_count``, and ``num_primitive_operations`` apply to algorithms that decompose the LHS and/or RHS into multiple components and execute multiple operations on those values, usually to emulate a higher precision. For algorithms with no decomposition, these values should be set to ``1``. * ``allow_imprecise_accumulation`` to specify if accumulation in lower precision is permitted for some steps (e.g. ``CUBLASLT_MATMUL_DESC_FAST_ACCUM``). The `StableHLO spec `_ for the dot operation doesn't require that the precision types be the same as the storage types for the inputs or outputs, but some platforms may require that these types match. Furthermore, the return type of :func:`~jax.lax.dot_general` is always defined by the ``accumulation_type`` parameter of the input algorithm, if specified. Examples: Accumulate two 16-bit floats using a 32-bit float accumulator: >>> algorithm = DotAlgorithm( ... lhs_precision_type=np.float16, ... rhs_precision_type=np.float16, ... accumulation_type=np.float32, ... ) >>> lhs = jnp.array([1.0, 2.0, 3.0, 4.0], dtype=np.float16) >>> rhs = jnp.array([1.0, 2.0, 3.0, 4.0], dtype=np.float16) >>> dot(lhs, rhs, precision=algorithm) # doctest: +SKIP array([ 1., 4., 9., 16.], dtype=float16) Or, equivalently, using a preset: >>> algorithm = DotAlgorithmPreset.F16_F16_F32 >>> dot(lhs, rhs, precision=algorithm) # doctest: +SKIP array([ 1., 4., 9., 16.], dtype=float16) Presets can also be specified by name: >>> dot(lhs, rhs, precision="F16_F16_F32") # doctest: +SKIP array([ 1., 4., 9., 16.], dtype=float16) The ``preferred_element_type`` parameter can be used to return the output without downcasting the accumulation type: >>> dot(lhs, rhs, precision="F16_F16_F32", preferred_element_type=np.float32) # doctest: +SKIP array([ 1., 4., 9., 16.], dtype=float32) rAlhs_precision_typerhs_precision_typeaccumulation_typerNrlhs_component_countrhs_component_countnum_primitive_operationsFrallow_imprecise_accumulationc ~~tjjtjt j |jtjt j |jtjt j |j|j|j|j|jSrY)r5rLrr(dtype_to_ir_typerrbrMrNrOrPrQrRrS)r lhs_dtype rhs_dtypes rT_convert_to_hlo_attrz!DotAlgorithm._convert_to_hlo_attrQs9      fll4+B+BCD fll4+B+BCD fll4+A+ABC       %% )) rVN)rVrArWrAr?zhlo.DotAlgorithm) rrrr__annotations__rPrQrRrSrXrirVrTrLrLs^AF ss"#C#',, &/ 4D rVrLceZdZdZej Z ej Z ej Z ej Z ej Z ej Z ej Z ej Z ej Zej Z ej Z ej Z ej Zej Z ej Zej Zd dZd dZed dZed dZed dZ d dZ ddZy )DotAlgorithmPresetaAn enum of known algorithms for computing dot products. This ``Enum`` provides a named set of :class:`~jax.lax.DotAlgorithm` objects that are known to be supported on at least platform. See the :class:`~jax.lax.DotAlgorithm` documentation for more details about the behavior of these algorithms. An algorithm can be selected from this list when calling :func:`~jax.lax.dot`, :func:`~jax.lax.dot_general`, or most other JAX dot product functions, by passing either a member of this ``Enum`` or it's name as a string using the ``precision`` argument. For example, users can specify the preset using this ``Enum`` directly: >>> lhs = jnp.array([1.0, 2.0, 3.0, 4.0], dtype=np.float16) >>> rhs = jnp.array([1.0, 2.0, 3.0, 4.0], dtype=np.float16) >>> algorithm = DotAlgorithmPreset.F16_F16_F32 >>> dot(lhs, rhs, precision=algorithm) # doctest: +SKIP array([ 1., 4., 9., 16.], dtype=float16) or, equivalently, they can be specified by name: >>> dot(lhs, rhs, precision="F16_F16_F32") # doctest: +SKIP array([ 1., 4., 9., 16.], dtype=float16) The names of the presets are typically ``LHS_RHS_ACCUM`` where ``LHS`` and ``RHS`` are the element types of the ``lhs`` and ``rhs`` inputs respectively, and ``ACCUM`` is the element type of the accumulator. Some presets have an extra suffix, and the meaning of each of these is documented below. The supported presets are: cL|jjd|jSr4r5r7s rTr8zDotAlgorithmPreset.__repr__r9rVc|jSrYr;r7s rTr<zDotAlgorithmPreset.__str__r=rVcl|xxtjk(ryxtjk(r yxtjk(r yxtjk(r yxtj k(r yxxtj k(rnxtjk(rnntjfSxxtjk(rnxtjk(rnn"tjtjfStjk(rtj fS tjfSrY)r[rANY_F8_ANY_F8_F32ANY_F8_ANY_F8_F32_FAST_ACCUMANY_F8_ANY_F8_ANYANY_F8_ANY_F8_ANY_FAST_ACCUM F16_F16_F16 F16_F16_F32rZfloat16BF16_BF16_BF16 BF16_BF16_F32rrIrD F64_F64_F64float64r7s rTsupported_lhs_typesz&DotAlgorithmPreset.supported_lhs_typess   < $  $ $ <  1  0 0 <  <  ; ; <  1  0 0 <  <  ; ;  <   < K )  ) ),J,>,J,J J } + +  + + *  * * + ,,  ) ) }  }rVc|jSrY)rjr7s rTsupported_rhs_typesz&DotAlgorithmPreset.supported_rhs_typess  # ##rVc|xxtjk(ryxtjk(r yxtjk(r yxtjk(rt j Sxtjk(rtjStjk(rt jS t jSrY) r[rrarbrcrZrerfrrIrhrirDr7s rTrOz$DotAlgorithmPreset.accumulation_types  < $  $ $ < 1  0 0 < <  ; ; <  < *  ) )zz ,  , ,  ) )zz zzrVc&|xxtjk(rnxtjk(rnn|tjtj t jt jt jt jt jt jfSxtjk(rYt j||tj k(r tjtj fStjfStjk(rXt j||t jk(r tjt jfStjfS |j }|dS|fSrY)r[r_r`rZrDrerrI float8_e4m3fn float8_e5m2float8_e5m2fnuzfloat8_e4m3fnuzfloat8_e4m3b11fnuzrd promote_typesrgrO)rrVrWrOs rTsupported_output_typesz)DotAlgorithmPreset.supported_output_typess!  < .  . . ;  ; ; < JJ JJ OO      " "  " "  % %   *  ) )    9 5 C**bjj) )**   + +    9 5 H**foo. .**   22(0tJ7H6JJrVc h tjj}tjj}tjj}tj j}tj j}|xxtjk(rn?xtjk(rn+xtjk(rnxtjk(rnntjtjtjtj tjtj"tjtj$tjtj&tjtj(tjtj*tjtj,g}||vs||vrt/d|d|d|dt1j2tj|} t1j2tj|} tjj} t4j6j| | | ddd|tjk(Sxtj8k(r&t4j6j|||ddddSxtj:k(r&t4j6j|||ddddSxtj<k(r&t4j6j|||ddddSxtj>k(r&t4j6j|||ddddSxtj@k(r&t4j6j|||ddddSxtjBk(r&t4j6j|||ddddSxtjDk(r&t4j6j|||ddd dSxtjFk(r&t4j6j|||ddddSxtjHk(r&t4j6j|||ddddSxtjJk(r&t4j6j|||ddddStjLk(r%t4j6j|||ddddS y) NzThe dot algorithm 'z2' requires both inputs to have float8 dtypes. Got  and z instead.rNF )'r3F16TyperF32TypeF64TypeBF16Type FloatTF32Typer[r_r`rarbrZrbrrsrorrrprq float8_e3m4 float8_e4m3float8_e8m0fnurr(rUr5rLrcrdrfrgBF16_BF16_F32_X3BF16_BF16_F32_X6BF16_BF16_F32_X9 TF32_TF32_F32TF32_TF32_F32_X3 F32_F32_F32rh) rrVrWf16f32f64bf16tf32 fp8_dtypeslhsrhsaccs rTrXz'DotAlgorithmPreset._convert_to_hlo_attr s **.. C **.. C **.. C ;;?? D     !D  < .  . . ;  ; ; 0  0 0 ;  ; ; < HHV.. / HHV)) * HHV++ , HHV'' ( HHV++ , HHV'' ( HHV'' ( HHV** +   J &):*E#D6*&KuYKyB  ##FLL$;<##FLL$;<jjnn##    &CC C   *  ) )##Cc1aEBB )  ) )##Cc1aEBB ,  , ,##D$aAuEE +  + +##D$Q1eDD .  . .##D$Q1eDD .  . .##D$Q1eDD .  . .##D$Q1eDD +  + +##D$Q1eDD .  . .##D$Q1eDD )  ) )##Cc1aEBB  ) )##Cc1aEBB rVNr@)r?tuple[DTypeLike, ...] | None)r?DTypeLike | None)rVrArWrAr?r)rVrArWrAr?hlo.DotAlgorithm | None)rrrrenumautorr_r`rarbrcrdrfrgrrrrrrrhr8r<propertyrjrlrOrurXrirVrTr[r[_s> DIIK'FdiikD!* diik"+ + +499;.$))+-TYY[TYY[GTYY[G$))+-TYY[ + +4  2 $ $  " K  K-6 K# KD@'0@5L@rVr[ out_shardingc$t||||||S)zAlias of :func:`jax.lax.dot`. Prefer use of :func:`jax.lax.dot` directly, but note that it requires all arguments after ``lhs`` and ``rhs`` to be specified by keyword rather than position. dimension_numbers precisionpreferred_element_typer)dot)rrrrrrs rT dot_generalr] s! S#):i$: WWrVrc|rqtjdddt|dk(r| td|\}n9t|dk(r | td| td|\}}n td ~t j |}t|}t j |} t| } |Td|cxkrdkr8nn5d| cxkrdkr*nn't j|d | d r |dz fd fd f}ntd|d| t|d}|\\} } \} }tj| tj| f}tj| tj|f}|dntj|d}t j||\}}tj!||||ft#|||S)ay General dot product/contraction operator. This operation lowers directly to the `stablehlo.dot_general`_ operation. The semantics of ``dot_general`` are complicated, but most users should not have to use it directly. Instead, you can use higher-level functions like :func:`jax.numpy.dot`, :func:`jax.numpy.matmul`, :func:`jax.numpy.tensordot`, :func:`jax.numpy.einsum`, and others which will construct appropriate calls to ``dot_general`` under the hood. If you really want to understand ``dot_general`` itself, we recommend reading XLA's DotGeneral_ operator documentation. Args: lhs: an array rhs: an array dimension_numbers: an optional tuple of tuples of sequences of ints of the form ``((lhs_contracting_dims, rhs_contracting_dims), (lhs_batch_dims, rhs_batch_dims))``. This may be left unspecified in the common case of un-batched matrix-matrix, matrix-vector, or vector-vector dot products, as determined by the shape of ``lhs`` and ``rhs``. precision: Optional. This parameter controls the numerics of the computation, and it can be one of the following: - ``None``, which means the default precision for the current backend, - a :class:`~jax.lax.Precision` enum value or a tuple of two :class:`~jax.lax.Precision` enums indicating precision of ``lhs``` and ``rhs``, or - a :class:`~jax.lax.DotAlgorithm` or a :class:`~jax.lax.DotAlgorithmPreset` indicating the algorithm that must be used to accumulate the dot product. preferred_element_type: Optional. This parameter controls the data type output by the dot product. By default, the output element type of this operation will match the ``lhs`` and ``rhs`` input element types under the usual type promotion rules. Setting ``preferred_element_type`` to a specific ``dtype`` will mean that the operation returns that element type. When ``precision`` is not a :class:`~jax.lax.DotAlgorithm` or :class:`~jax.lax.DotAlgorithmPreset`, ``preferred_element_type`` provides a hint to the compiler to accumulate the dot product using this data type. out_sharding: an optional sharding specification for the output. If not specified, it will be determined automatically by the compiler. Returns: An array whose first dimensions are the (shared) batch dimensions, followed by the ``lhs`` non-contracting/non-batch dimensions, and finally the ``rhs`` non-contracting/non-batch dimensions. .. _stablehlo.dot_general: https://openxla.org/stablehlo/spec#dot_general .. _DotGeneral: https://www.openxla.org/xla/operation_semantics#dotgeneral zjax-lax-dot-positional-argszqjax.lax.dot: passing precision or preferred_element_type by position is deprecated; pass them by keyword instead.rMrrNNz8jax.lax.dot got multiple values for argument 'precision'zEjax.lax.dot got multiple values for argument 'preferred_element_type'z4Too many positional arguments passed to jax.lax.dot.rr)ririzjax.lax.dot: dimension_numbers must be specified when not performing simple un-batched matrix-matrix, matrix-vector, or vector-vector products; got lhs_shape=z rhs_shape=rrr)rrrrprZrqrrrr:r_ensure_index_tuplerrr dot_general_prcanonicalize_precision)rrrrrrr lhs_shapelhs_ndim rhs_shaperhs_ndim lhs_contract rhs_contract lhs_batch rhs_batchcdimsbdimss rTrrm sn # 8  4yA~  RSSji Ta  RSS  +_``*.'i' L MM hhsm) ^(hhsm) ^(Ha80q0T5J5J9UW=ZcdeZf5g%\OT2H=  |. s BqeCqM" Bs#%rr)super __setattr__r)rrrrr6s rTrz"RaggedDotDimensionNumbers.__init__ sR G B,A BB G/7L1MN G.6J0KLrV)rrrrrYr __classcell__)r6s@rTrr s( -,&&%%MMrVrc>t|tr |jS|SrY)rrr)rs rT_from_maybe_raggedr s* )+D E11 !rVrNrrrc tj|||\}}}tj||||t |||S)aiRagged matrix multiplication. Ragged dot takes three arrays---``lhs``, ``rhs``, and ``group_sizes``---and a ``ragged_dot_dimension_numbers`` argument. Like `dot_general`, ``lhs`` and ``rhs`` are allowed arbitrary batch and contracting dimensions. Additionally, ``lhs`` is required to have one ragged dimension, and ``rhs`` may have at most one group dimension. Let `g` be the number of groups in the lhs ragged dimension. Ragged dot has three modes, depending on the kind of the lhs ragged dimension: 1. ``[b...,m...,k...], [g,b...,k...,n...], [b...,x...,g] -> [b...,m...,n...]``. Here the ragged dimension is a non-contracting dimension (``m``) of ``lhs``, and ``x...`` are the lhs non-contracting dims outer to the ragged dim. 2. ``[b...,m...,k...], [b...,k...,n...], [b...,x...,g] -> [g,b...,m...,n...]``. Here the ragged dimension is a contracting dimension (``k``) of ``lhs`` and ``rhs``, and `x...` are the lhs contracting dims outer to the ragged dim. 3. ``[b...,m...,k...], [b...,k...,n...], [x...,g] -> [b...,m...,n...]``. Here the ragged dimension is a batch dimension (``b``) of ``lhs`` and ``rhs``, and ``x...`` are the lhs batch dims outer to the ragged dim. If ``group_sizes`` is passed-in with shape ``[g]``, it is broadcasted according to the rules above. Args: lhs: an array rhs: an array group_sizes: an array with integer element type ragged_dot_dimension_numbers: a ``RaggedDotDimensionNumbers`` object to specify the dot dimension numbers, lhs ragged dimension, and rhs group dimension. precision: Optional. Consistent with precision argument for :func:`jax.lax.dot`. preferred_element_type: Optional. Consistent with precision argument for :func:`jax.lax.dot`. group_offset: Optional. (1,) shaped array that indicates the group in group_sizes to start computing from. If not specified, defaults to [0]. Results: An array whose shape is the same as that produced by `dot_general`, with an extra leading dimension of size `g` in the case where the lhs ragged dimension is a contracting dimension. r)rrragged_dot_general_prr)rrrrrrrs rTrr+ sRh44S#{K#sK  " "  #?&y13 # rVc t|dk(r | t|Sttt|t|t j |z}t |t|t j|z||S)a]Broadcasts an array, adding new leading dimensions Args: operand: an array sizes: a sequence of integers, giving the sizes of new leading dimensions to add to the front of the array. Returns: An array containing the result. See Also: jax.lax.broadcast_in_dim : add new dimensions at any location in the array shape. rr)rrrrQrZrObroadcast_in_dimrq)rr(rdimss rT broadcastrk sn Z1_- 7  uSZUbggg.>!>? @$ '5<"((72C#CT'3 55rVrqct|d}tj|t|k(rt|st |t r||St j|}|j|k(rQt|tt|jk(r'|%|j|k7rtj||Stj|t!|t!||S)aWraps XLA's `BroadcastInDim `_ operator. Args: operand: an array shape: the shape of the target array broadcast_dimensions: to which dimension in the target shape each dimension of the operand shape corresponds to. That is, dimension i of the operand becomes dimension broadcast_dimensions[i] of the result. Returns: An array containing the result. See Also: jax.lax.broadcast : simpler interface to add new leading dimensions. rrqbroadcast_dimensionsr)r:rZrOrrr<rtypeofrqrrQrrreshardbroadcast_in_dim_prr)rrqrr operand_avals rTrr s('|5GH,ggg#e*$S1E-F% \%9 NW%,E!  D|/@/@)A$BB<#8#8L#H << ..   U5\ !56 ! OOrVcptj|}||k(r t|St|d||z zS)z=Adds leading dimensions of ``1`` to give ``x`` rank ``rank``.r)rZrOrr)rSrankrOs rTbroadcast_to_rankr s6 $ T\ 1: 1ddTk* ++rVc<t|}t|}tjt j ||}|d}d}nHt j|}t|ttt j|k(}t|d}|duxs"tj|j|k(}t j |r|r|r|rt|tr|Stj!|t|||rd|S||S)aaWraps XLA's `Reshape `_ operator. For inserting/removing dimensions of size 1, prefer using ``lax.squeeze`` / ``lax.expand_dims``. These preserve information about axis identity that may be useful for advanced transformation rules. Args: operand: array to be reshaped. new_sizes: sequence of integers specifying the resulting shape. The size of the final array must match the size of the input. dimensions: optional sequence of integers specifying the permutation order of the input shape. If specified, the length must match ``operand.shape``. Returns: out: reshaped array. Examples: Simple reshaping from one to two dimensions: >>> x = jnp.arange(6) >>> y = reshape(x, (2, 3)) >>> y Array([[0, 1, 2], [3, 4, 5]], dtype=int32) Reshaping back to one dimension: >>> reshape(y, (6,)) Array([0, 1, 2, 3, 4, 5], dtype=int32) Reshaping to one dimension with permutation of dimensions: >>> reshape(y, (6,), (1, 0)) Array([0, 3, 1, 4, 2, 5], dtype=int32) NTreshape new_sizes dimensionsr)r#rrrrZrqrrrQrOr:rrrr< reshape_pr)rrrr same_shape same_dimsr same_shardings rTrr sP!+)I)**288G+> y)  8<  rVcvtj||\}}tj||t |S)asApplies low, high, and/or interior padding to an array. Wraps XLA's `Pad `_ operator. Args: operand: an array to be padded. padding_value: the value to be inserted as padding. Must have the same dtype as ``operand``. padding_config: a sequence of ``(low, high, interior)`` tuples of integers, giving the amount of low, high, and interior (dilation) padding to insert in each dimension. Negative values for ``low`` and ``high`` are allowed and remove elements from the edges of the array. Returns: The ``operand`` array with padding value ``padding_value`` inserted in each dimension according to the ``padding_config``. Examples: >>> from jax import lax >>> import jax.numpy as jnp Pad a 1-dimensional array with zeros, We'll specify two zeros in front and three at the end: >>> x = jnp.array([1, 2, 3, 4]) >>> lax.pad(x, 0, [(2, 3, 0)]) Array([0, 0, 1, 2, 3, 4, 0, 0, 0], dtype=int32) Pad a 1-dimensional array with *interior* zeros; i.e. insert a single zero between each value: >>> lax.pad(x, 0, [(0, 0, 1)]) Array([1, 0, 2, 0, 3, 0, 4], dtype=int32) Pad a 2-dimensional array with the value ``-1`` at front and end, with a pad size of 2 in each dimension: >>> x = jnp.array([[1, 2, 3], ... [4, 5, 6]]) >>> lax.pad(x, -1, [(2, 2, 0), (2, 2, 0)]) Array([[-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, 1, 2, 3, -1, -1], [-1, -1, 4, 5, 6, -1, -1], [-1, -1, -1, -1, -1, -1, -1], [-1, -1, -1, -1, -1, -1, -1]], dtype=int32) Use negative padding to remove elements from the edges of an array: >>> x = jnp.array([1, 2, 3, 4, 5], dtype=jnp.int32) >>> lax.pad(x, 0, [(-1, -2, 0)]) Array([2, 3], dtype=int32) padding_config)rrpad_prr)r padding_valuers rTpadr s6r 55g}M'= G]5;P QQrVcBtj|t|S)zaWraps XLA's `Rev `_ operator. r)rev_prrrrs rTrevr" s Gj(9 ::rVcftj|||\}}}tj|||S)aESelects between two branches based on a boolean predicate. Wraps XLA's `Select `_ operator. In general :func:`~jax.lax.select` leads to evaluation of both branches, although the compiler may elide computations if possible. For a similar function that usually evaluates only a single branch, see :func:`~jax.lax.cond`. Args: pred: boolean array on_true: array containing entries to return where ``pred`` is True. Must have the same shape as ``pred``, and the same shape and dtype as ``on_false``. on_false: array containing entries to return where ``pred`` is False. Must have the same shape as ``pred``, and the same shape and dtype as ``on_true``. Returns: result: array with same shape and dtype as ``on_true`` and ``on_false``. )rr select_n_pr)predon_trueon_falses rTselectr) s5.!66 Hg$' x 11rVct|dk(r tdtj|g|^}}t j |g|S)axSelects array values from multiple cases. Generalizes XLA's `Select `_ operator. Unlike XLA's version, the operator is variadic and can select from many cases using an integer `pred`. Args: which: determines which case should be returned. Must be an array containing either a boolean or integer values. May either be a scalar or have shape matching ``cases``. For each array element, the value of ``which`` determines which of ``cases`` is taken. ``which`` must be in the range ``[0 .. len(cases))``; for values outside that range the behavior is implementation-defined. *cases: a non-empty list of array cases. All must have equal dtypes and equal shapes. Returns: An array with shape and dtype equal to the cases, whose values are chosen according to ``which``. rz&select_n() must have at least one case)rrrrrrwhichcasess rTselect_nrD sH* Z1_ = >>,,U;U;-%%  ' ''rVctd|D}|tttj|k(rt |t r|St j||S)zeWraps XLA's `Transpose `_ operator. c3FK|]}tj|ywrY)operatorindexrjrzs rTrlztranspose..e s=AhnnQ'=r) permutation)rrQrZrOrr< transpose_pr)rrs rTrPrP_ sS ===+E% 0122z'57Q N   G  ==rVc`tj|d}tj||f|S)z9Computes the index of the minimum element along ``axis``.argminaxes index_dtype)rrargmin_prrr)rs rTrrk -88hO+ wdW+ FFrVc`tj|d}tj||f|S)z9Computes the index of the maximum element along ``axis``.argmaxr)rrargmax_prrs rTr r q rrVc(tj|\}}tjd|||fi}tj|\}} || k7rt d|d| t |t |k7r#t dt |dt |t ||} | rXtj|xrtj|} || turt|d|ini} | g||i| } t| | Sttj|}t||t!|| \}}tj"|}tj"|}t%j&g||||t!|d} tj(|| S)aWraps XLA's `Reduce `_ operator. ``init_values`` and ``computation`` together must form a `monoid `_ for correctness. That is ``init_values`` must be an identity of ``computation``, and ``computation`` must be associative. XLA may exploit both of these properties during code generation; if either is violated the result is undefined. z reduce compz;Operands must have the same tree structure as init_values: z vs. z9Must have same total number of operands as init_values: rr) computationrr)rrrrrr_get_monoid_reducerrr reduce_sumrrrErr_variadic_reduction_jaxprrrreduce_prr)r# init_valuesr rr flat_operands operand_tree comp_debugflat_init_valuesinit_value_treemonoid_reducerrout_sharding_dictoutflat_init_avalsrrs rTreducerw s !* 6 6x @-""=+$/#=rC*&/&<&<[&I#O_$ %eO+<> ??3/00 ]+,E#6F2G1HJ KK&{4DE.''7;'')9:N*$D (4),7:<  I- I I7H IC  ::t}}.>?O6Z!7JL(.. >M113CD -- J J)9 J{*uZ7H JC  # #Hc 22rVc fd}tj|tjd||fi}t j |||f\}}}t d|Dr td|t|fS)Nc||}t|tjs/tj|st dt |d||fS)Nz-Invalid return type from reduction function: zE Reduction functions should only return an array. Full return value: )rrr valid_jaxtyperr)rSr$resultr s rTcompz_reduction_jaxpr..comp s\ A F vt{{ +t/A/A&/I  9$v,H &x ) ** 9rVreduction_jaxprrc3PK|]}t|tj ywrYrrs rTrlz#_reduction_jaxpr.. rrgReduction computations can't close over Tracers. Please open an issue at https://github.com/jax-ml/jax.) rrrrrrrrr)r rr! comp_wrappedrrrs` rT_reduction_jaxprr& s $$%6 &*D\278,..|dD\J%F4V44  , -- f rVc|tj||}tj||f\}}tj||}t j ||\}} tj|t|\} } } td| Dr tdtj| | | fS)Nrc3PK|]}t|tj ywrYrrs rTrlz,_variadic_reduction_jaxpr.. rrr$)rrrrrrrrrrrrr ClosedJaxpr) r r flat_avals aval_treer flat_in_avalsrr! flat_comprrrrs rTrr s  " "9j 9%$115%.A- kj 9$ 55dGD)X..y% :NO%F4V44  , --   % ((* 44rVct|dk7ry|\}tj|}t|}tj|r|j dk(rtj |}|tjk(xs$tj|tj}|turtj|drtSdS|turtj|drt SdS|t"ur)|r'tj|t%|rt&SdS|t(ur)|r'tj|t+|rt,SdS|t.ur)|r'tj|t%|rt0SdS|t2ur'tj|t5|rt6SdS|t8ur'tj|t;|rt<SdSy)NrNrir)rrrr1rrqto_concrete_valuerZbool_rrintegerr]equalrrd reduce_prodrQ_get_bitwise_or_identity reduce_orrM_get_bitwise_and_identity reduce_andrT reduce_xorr`_get_max_identity reduce_maxr^_get_min_identity reduce_min) monoid_opxsrSrrbra _is_intlikes rTrr sW\  "! q $ )% aTZZ2-   #C288#Kv'8'8 'KKC88C+Z55 c HHS!,[6$6 j [((3(@(GHYRdR k !k88C)B5)IJZTPTT k !k88C)A%)HIZStS c 88C):5)ABZLL c 88C):5)ABZLL rVrbcJtjdj|SNr)rZrrrs rTr6r6 s "  U ##rVc.tjd|SNrrZrrs rTr4r4  !U rVc.tjd|SrCrDrs rT_get_sum_identityrG rErVc.tjd|SNrNrDrs rT_get_prod_identityrJ rErVcdtj|tjr`tjtj |rtj |Stj|j|Stj|tjr3tjtj|j|Stj|tjr$tjdtjStd|)NrFzUnsupported dtype for max: ) rrrZinexactr supports_infinffinfor^r1r[r0rrs rTr9r9 s ubjj) 88v2259RVVG !!v||E?R?V?V !!  + 88FLL'++U 33 ) 88E288 $$ 25': ;;rVcbtj|tjr_tjtj |rtj |Stj|j|Stj|tjr3tjtj|j|Stj|tjr$tjdtjStd|)NrTzUnsupported dtype for min: ) rrrZrLrrMrNrOr`r1r[r0rrs rTr;r; s ubjj) 88f11%8BFF !!fll5>Q>U>U !!  + 88FLL'++U 33 ) 88D"(( ## 25': ;;rVc\t|d}tj|t||S)aCompute the sum of elements over one or more array axes. Args: operand: array over which to sum. Must have numerical dtype. axes: sequence of zero or more unique integers specifying the axes over which to sum. Each entry must satisfy ``0 <= axis < operand.ndim``. Returns: An array of the same dtype as ``operand``, with shape corresponding to the dimensions of ``operand.shape`` with ``axes`` removed. Notes: Unlike :func:`jax.numpy.sum`, :func:`jax.lax.reduce_sum` does not upcast narrow-width types for accumulation, so sums of 8-bit or 16-bit types may be subject to rounding errors. See also: - :func:`jax.numpy.sum`: more flexible NumPy-style summation API, built around :func:`jax.lax.reduce_sum`. - Other low-level :mod:`jax.lax` reduction operators: :func:`jax.lax.reduce_prod`, :func:`jax.lax.reduce_max`, :func:`jax.lax.reduce_min`, :func:`jax.lax.reduce_and`, :func:`jax.lax.reduce_or`, :func:`jax.lax.reduce_xor`. r)rr)r: reduce_sum_prr)rrrs rTrr s,2'|\B,   7t<  PPrVcBtj|t|S)aCompute the product of elements over one or more array axes. Args: operand: array over which to sum. Must have numerical dtype. axes: sequence of zero or more unique integers specifying the axes over which to sum. Each entry must satisfy ``0 <= axis < operand.ndim``. Returns: An array of the same dtype as ``operand``, with shape corresponding to the dimensions of ``operand.shape`` with ``axes`` removed. Notes: Unlike :func:`jax.numpy.prod`, :func:`jax.lax.reduce_prod` does not upcast narrow-width types for accumulation, so products of 8-bit or 16-bit types may be subject to rounding errors. See also: - :func:`jax.numpy.prod`: more flexible NumPy-style product API, built around :func:`jax.lax.reduce_prod`. - Other low-level :mod:`jax.lax` reduction operators: :func:`jax.lax.reduce_sum`, :func:`jax.lax.reduce_max`, :func:`jax.lax.reduce_min`, :func:`jax.lax.reduce_and`, :func:`jax.lax.reduce_or`, :func:`jax.lax.reduce_xor`. r) reduce_prod_prrrrs rTr3r3% s0   G%+  66rVcBtj|t|S)aCompute the maximum of elements over one or more array axes. Args: operand: array over which to compute maximum. axes: sequence of zero or more unique integers specifying the axes over which to reduce. Each entry must satisfy ``0 <= axis < operand.ndim``. Returns: An array of the same dtype as ``operand``, with shape corresponding to the dimensions of ``operand.shape`` with ``axes`` removed. See also: - :func:`jax.numpy.max`: more flexible NumPy-style max-reduction API, built around :func:`jax.lax.reduce_max`. - Other low-level :mod:`jax.lax` reduction operators: :func:`jax.lax.reduce_sum`, :func:`jax.lax.reduce_prod`, :func:`jax.lax.reduce_min`, :func:`jax.lax.reduce_and`, :func:`jax.lax.reduce_or`, :func:`jax.lax.reduce_xor`. rT) reduce_max_prrrVs rTr:r:? &   7t  55rVcBtj|t|S)aCompute the minimum of elements over one or more array axes. Args: operand: array over which to compute minimum. axes: sequence of zero or more unique integers specifying the axes over which to reduce. Each entry must satisfy ``0 <= axis < operand.ndim``. Returns: An array of the same dtype as ``operand``, with shape corresponding to the dimensions of ``operand.shape`` with ``axes`` removed. See also: - :func:`jax.numpy.min`: more flexible NumPy-style min-reduction API, built around :func:`jax.lax.reduce_min`. - Other low-level :mod:`jax.lax` reduction operators: :func:`jax.lax.reduce_sum`, :func:`jax.lax.reduce_prod`, :func:`jax.lax.reduce_max`, :func:`jax.lax.reduce_and`, :func:`jax.lax.reduce_or`, :func:`jax.lax.reduce_xor`. rT) reduce_min_prrrVs rTr<r<T rYrVcBtj|t|S)abCompute the bitwise OR of elements over one or more array axes. Args: operand: array over which to compute the reduction. Must have boolean or integer dtype. axes: sequence of zero or more unique integers specifying the axes over which to reduce. Each entry must satisfy ``0 <= axis < operand.ndim``. Returns: An array of the same dtype as ``operand``, with shape corresponding to the dimensions of ``operand.shape`` with ``axes`` removed. See also: - :func:`jax.numpy.bitwise_or.reduce`: more flexible NumPy-style logical reduction API, built around :func:`jax.lax.reduce_or`. - Other low-level :mod:`jax.lax` reduction operators: :func:`jax.lax.reduce_sum`, :func:`jax.lax.reduce_prod`, :func:`jax.lax.reduce_max`, :func:`jax.lax.reduce_min`, :func:`jax.lax.reduce_and`, :func:`jax.lax.reduce_xor`. rT) reduce_or_prrrVs rTr5r5i s(   'd  44rVcBtj|t|S)adCompute the bitwise AND of elements over one or more array axes. Args: operand: array over which to compute the reduction. Must have boolean or integer dtype. axes: sequence of zero or more unique integers specifying the axes over which to reduce. Each entry must satisfy ``0 <= axis < operand.ndim``. Returns: An array of the same dtype as ``operand``, with shape corresponding to the dimensions of ``operand.shape`` with ``axes`` removed. See also: - :func:`jax.numpy.bitwise_and.reduce`: more flexible NumPy-style logical reduction API, built around :func:`jax.lax.reduce_and`. - Other low-level :mod:`jax.lax` reduction operators: :func:`jax.lax.reduce_sum`, :func:`jax.lax.reduce_prod`, :func:`jax.lax.reduce_max`, :func:`jax.lax.reduce_min`, :func:`jax.lax.reduce_or`, :func:`jax.lax.reduce_xor`. rT) reduce_and_prrrVs rTr7r7 (   7t  55rVcBtj|t|S)adCompute the bitwise XOR of elements over one or more array axes. Args: operand: array over which to compute the reduction. Must have boolean or integer dtype. axes: sequence of zero or more unique integers specifying the axes over which to reduce. Each entry must satisfy ``0 <= axis < operand.ndim``. Returns: An array of the same dtype as ``operand``, with shape corresponding to the dimensions of ``operand.shape`` with ``axes`` removed. See also: - :func:`jax.numpy.bitwise_xor.reduce`: more flexible NumPy-style logical reduction API, built around :func:`jax.lax.reduce_xor`. - Other low-level :mod:`jax.lax` reduction operators: :func:`jax.lax.reduce_sum`, :func:`jax.lax.reduce_prod`, :func:`jax.lax.reduce_max`, :func:`jax.lax.reduce_min`, :func:`jax.lax.reduce_and`, :func:`jax.lax.reduce_or`. rT) reduce_xor_prrrVs rTr8r8 r`rVrcyrYrirr! is_stablenum_keyss rTsortrg s>ArVcyrYrirds rTrgrg sJMrVc t|trt|dk(r tdd|cxkrt|ksnt d|dt|t |t|dj }tj|}ttj||||dS|dk7rt d|dt |t|j }tj|||ddS)avWraps XLA's `Sort `_ operator. For floating point inputs, -0.0 and 0.0 are treated as equivalent, and NaN values are sorted to the end of the array. For complex inputs, the sort order is lexicographic over the real and imaginary parts, with the real part primary. Args: operand : Array or sequence of arrays dimension : integer dimension along which to sort. Default: -1. is_stable : boolean specifying whether to use a stable sort. Default: True. num_keys : number of operands to treat as sort keys. Default: 1. For num_keys > 1, the sort order will be determined lexicographically using the first `num_keys` arrays, with the first key being primary. The remaining operands will be returned with the same permutation. Returns: operand : sorted version of the input or inputs. rz"Sort requires at least one operandrNz num_keys=z$ must be between 1 and len(operand)=r!rerfz# must equal 1 for a single operand.) rrrrprrDrqrrrsort_prrds rTrgrg s*" 7|q : ;;  )S\ ) )($ICL?K LL!)S1A1A-BCI(('2G g'0&.0 111} )($GH II!)S-?@I ;;w)yST; UVW XXrVct|t|j}tj ||||d\}}||fS)zRSorts ``keys`` along ``dimension`` and applies the same permutation to ``values``.rNrj)rDrrqrkr)keysrr!rerrs rT sort_key_valrn s> 3tzz?;) T6Y)VW X$!Q A+rVr)ctj|r t|}|dkrtd|t |t j |}tj|||S)aiReturns top ``k`` values and their indices along the specified axis of ``operand``. Args: operand: N-dimensional array of non-complex type. k: integer specifying the number of top entries. axis: optional integer specifying the axis along which to compute the top ``k`` entries. Default is -1, indicating the last axis. Returns: A tuple ``(values, indices)`` where - ``values`` is an array containing the top k values along the last axis. - ``indices`` is an array containing the indices corresponding to values. ``values[..., i, ...]`` is the ``i``-th largest entry in ``operand`` along the specified axis, and its index is ``indices[..., i, ...]``. If two elements are equal, the lower-index element appears first. See also: - :func:`jax.lax.approx_max_k` - :func:`jax.lax.approx_min_k` Examples: Find the largest three values, and their indices, within an array: >>> x = jnp.array([9., 3., 6., 4., 10.]) >>> values, indices = jax.lax.top_k(x, 3) >>> values Array([10., 9., 6.], dtype=float32) >>> indices Array([4, 0, 2], dtype=int32) r-k argument to top_k must be nonnegative, got rr)) ris_constant_dimrrrDrZrOtop_k_pr)rrr)s rTtop_kru s`D ! AAU DQCH II 4!1 2$ g ..rVc|S)z,Deprecated. Ignores ``x`` and returns ``y``.rir#s rTtie_inrw s (rVrct|}tj|r/d}t|j tj||!t j |}t|}nYt j|t jr|jj|||Sd}t j|d}t|||}|t|tspt|t j"rV|j$rJ|j'|}t)||j+dt!j,||fd|S||j$st)|||St)||S)aReturns an array of `shape` filled with `fill_value`. Args: shape: sequence of integers, describing the shape of the output array. fill_value: the value to fill the new array with. dtype: the type of the output array, or `None`. If not `None`, `fill_value` will be cast to `dtype`. sharding: an optional sharding specification for the resulting array, note, sharding will currently be ignored in jitted mode, this might change in the future. zDfull must be called with scalar fill_value, got fill_value.shape {}.FfullrcSrYri)rshards rTrzfull.., s5rVrr)r#rZrqrpformatrrr1rextended_rulesrzrrrr7r ArrayImplr shard_shaperaddressable_datamake_array_from_callback) rq fill_valuerbrrsr fill_dtypebroadcast_shaper|s @rTrzrz sG U #%XXj PC CJJrxx 34 55 ]&&z2I #J 0 \\  uj% 88I99%HJ$ZYG*:h #EU__-(2G2G**51O j/ 2E  " "1 %E  ) ) x  <<("7"7 ZX >> Z ''rVc8t|tsJtj|jtj r0|jj j|j}n`|jtjk(r"tjd|j}n!td|j|j}t||j|j}t!j"|t%|j&S)Nrirrr)rr!rrrbr~rzerorrZzerosrrrrqrrpvaryrvma)r scalar_zerors rTzeros_like_shaped_arrayr3 s D+ && & tzz6??3**##((4K zzV]]"((2TZZ0K'4::t~~FK+tzz F# Ctxx ))rVcjtj|j}tj|SrY)r zeros_like_aval inner_avalrnew_ref)rras rTzeros_like_abstract_refr? s%0# c rVct||fdS)z[Wraps XLA's `Iota `_ operator. r)broadcasted_iota)rbsizes rTiotarH s %$! ,,rVctj|d}t|}tjt |d}t |d}tj||||S)z$Convenience wrapper around ``iota``.rz*dimension argument of lax.broadcasted_iotarbrqr!r) rrr#rconcrete_or_errorrr:iota_pr)rbrqr!rs rTrrO sh  2 25:L M% U #%$$ 9BD)&|5GH, 5(<  AArVc Lt|tjd}tj|d}t t ttj|dtj|ttj|d}tj||ddS)z:Like numpy.eye, create a 2D array with ones on a diagonal.z"argument `offset` of jax.numpy.eyeeyerrNFNr) rdrZint32rrrzr]rrr)rbrqoffsetbool_eyes rT_eyerZ s #FBHH$H J&  2 25% @% $RXXua8"((6:JK 5!46(  $ $X%.2 % 44rVctt|}tj|d}t t j ||}tt|Dcgc]}tt j||}}t|dd|ddDcgc]\}}t||}}}tjtt j"||dd} t%| ||Scc}wcc}}w)zAThis utility function exists for creating Kronecker delta arrays.deltaNrrNFr)rrrrrrZtakerQrruint32rrzrr_reducerand_r) rbrqr base_shapeiiotasi1i2eyesr s rT_deltard s S$$  2 25' B%RWWUD)**#j/* , BIIz1 5 ,% ,#&uSbz59#= >R"R* >$ > ! & & hmmT"eu ' & &% ..  , >s "C,C1c "ttj|}tj|j t jstd|tj|d}t j|j jt j|jksIt j|j jt j|jkDr#t j t j}tj|d}t!t#t%||d|j'|t%||d}t(j+||dd S) z=Like numpy.tri, create a 2D array with ones below a diagonal.zoffset must be an integer, got TsignedtrirrNFNr)rrdimension_as_valuerrrbrZr1rp lax_utilsint_dtype_for_shaper[r^r`int64rrr]rrrr)rbrqr shape_dtypebool_tris rT_trirq s$ 4**62 3&   6<< 4 5fZ@ AA--eDA+hhv||  288K#8#<#<< &,,  # #bhh{&;&?&? ?((288$K  2 25% @% $[%;MM+.0 eQ79( $ $X%.2 % 44rVc:fdtj|S)a Stops gradient computation. Operationally ``stop_gradient`` is the identity function, that is, it returns argument `x` unchanged. However, ``stop_gradient`` prevents the flow of gradients during forward or reverse-mode automatic differentiation. If there are multiple nested gradient computations, ``stop_gradient`` stops gradients for all of them. For some discussion of where this is useful, refer to :ref:`stopping-gradients`. Args: x: array or pytree of arrays Returns: input value is returned unchanged, but within autodiff will be treated as a constant. Examples: Consider a simple function that returns the square of the input value: >>> def f1(x): ... return x ** 2 >>> x = jnp.float32(3.0) >>> f1(x) Array(9.0, dtype=float32) >>> jax.grad(f1)(x) Array(6.0, dtype=float32) The same function with ``stop_gradient`` around ``x`` will be equivalent under normal evaluation, but return a zero gradient because ``x`` is effectively treated as a constant: >>> def f2(x): ... return jax.lax.stop_gradient(x) ** 2 >>> f2(x) Array(9.0, dtype=float32) >>> jax.grad(f2)(x) Array(0.0, dtype=float32) This is used in a number of places within the JAX codebase; for example :func:`jax.nn.softmax` internally normalizes the input by its maximum value, and this maximum value is wrapped in ``stop_gradient`` for efficiency. Refer to :ref:`stopping-gradients` for more discussion of the applicability of ``stop_gradient``. c tjtj|jtj r|St |tjr|jStjj|SrY) rrrrrbr~rr& JVPTracerprimalr stop_gradient_prrSstops rTrzstop_gradient..stop s^ q)//A h Ar|| $ !((^  $ $ ) )! ,,rV)rtree_maprs @rT stop_gradientr sZ-   D! $$rVctjtj|d}tjtj|d}tj |||S)zqWraps XLA's `ReducePrecision `_ operator. z.exponent_bits argument of lax.reduce_precisionz.mantissa_bits argument of lax.reduce_precision) exponent_bits mantissa_bits)rrrrreduce_precision_prrrrs rTreduce_precisionr s](( NNM#SU-(( NNM#SU-   /< ! >>rVctj|ttfd|D}|st |t r|St j||S)z6Squeeze any number of size 1 dimensions from an array.c36K|]}t|ywrY)rD)rjrrOs rTrlzsqueeze.. sK1-a6Kr)rZrOrsortedrr< squeeze_pr)rrrOs @rTsqueezer sI $VK KKL*  5%0 L * 55rVc,tt|t|k7rtd|tj|t|z}|Dcgc]}t ||}}tt|t|k7rtd|t |}ttj|}t|D]}|j|dt|Dcgc] }||vs| }}t|||Scc}wcc}w)z5Insert any number of size 1 dimensions into an array.z"repeated axis in lax.expand_dims: rN) rsetrrZrOrD frozensetrrqrinsertrQr)rrndim_outrrdims_setrbroadcast_dimss rT expand_dimsr sZS_, 9*F GG WWU^c*o -(2< =Q Ax ( =$ =T^s4y 9$@ AA t_(bhhuo&, ( a1$XD!!82CAD.D %~ >> >EsD / D9Dc|tj|n t|}|duxrtj|}| t |n t |}tj |tjr|jj|||S|3|1t|tjr|jj}n|duxrt|tj xryt|dxrk|jduxr[|jj xst#j$ xr,t'|ddxr| xr|tj|k(}|r |j}t|t)||||}t*j,j.r*:!= >> 7==B' ($mmCR D7*W]]23-??) ) $$rVct|j|jdkr/tdj|j|j|j|jk7r/tdj|j|j|jdz f}|jdz f}t t |jdz }t ||||f||ff|S)zBatch matrix multiplication.rMz9Arguments to batch_matmul must be at least 2D, got {}, {}z9Arguments to batch_matmul must have same ndim, got {}, {}rNr)_minrOrr}rrQr)rrrrrbatchs rT batch_matmulr6s #((CHH! PfSXXsxx0 22XX PfSXXsxx0 22((Q,,((Q,, chhl# $% S#| .s .s+!**61uEE!"%c3NK|]}tj|dywr)r+ index_in_dimrs rTrlz_iter..s# P!g""61u== Pr)rOrprrqrrQ)rns` rT_iterrsg [[A 0 11 FLLOA ..6s"((5/rVrirs`rTrr6s9rVc htjtjd|jSNri)rZr5rrb)rbrs rTrr7s BFF288B3F,G,M,MrVcyNFrirs rTrr9rVc  jtjk(rtd|dt fd|DsKd}t j}d|D}t|j ||dj||snjtjtjtjtjfvr$t|dt jd|jfi|S) NCalled a with a float0 array. float0s do not support any operations by design, because they are not compatible with non-trivial vector spaces. No implicit dtype conversion is done. You can use np.zeros_like(arr, dtype=np.float) to cast a float0 array to a regular zeros array. If you didn't expect to get a float0 you might have accidentally taken a gradient with respect to an integer argument.c3^K|]$}tjj|&ywrYrrrbrjrrs rTrlz"unop_dtype_rule..Gs" G!V  tzz1 - G*-z@{} does not accept dtype {}. Accepted dtypes are subtypes of {}.c34K|]}|jywrYrrs rTrlz"unop_dtype_rule..Js>!**>rz does not accept dtype z. Support for narrow-width integers is platform-dependent and limited to a few specific operations, e.g. basic arithmetic and type casting.) rbrrrprr0r}ruint2int2uint4int4) result_dtypeaccepted_dtypesrrsupports_narrow_intsrrstypenameaccepted_typenamess ` rTunop_dtype_ruler;<s ZZ6==  $@ @ AA G G G LCtzz*H>o> CJJtXtyy9K/LM NN DJJ6<<fll\b\g\g2h$h tf3ODJJ4O3PQ44 55 djj +F ++rVc |j|jj|jjjSNreducedrrrrr?)out_srrs rTunop_reduced_rulerBSs5 5::,,T]]5G5G5O5O,P QQrVc tt||||}ttd||tdtdt}t j ||S)Nr8rqrr sharding_rulevma_rule reduced_rule)rr;r2 _attrgetterrBr' defvectorized)r6r7rr8 dtype_ruleprims rTunoprMVsU ot,@B* K0*d*5j*A%0%7): <$  +rVcfdS)Nct|SrY)r)rSrrs rTrz..bswq$/?rVrir;s`rTrrbs?rV) require_sameallow_extended_dtypec  t|t|k(s J||ft|D]\} |r%t jtj r-||}t fd|DrG jtjk(rtd|d|dd} t j} djd|D} t| j|| ||| |r t|g|||i|S)Nc3^K|]$}tjj|&ywrYr,r-s rTrlz$naryop_dtype_rule..ls"?Av  Q/?r.r*z with a float0 at position ap. float0s do not support any operations by design, because they are not compatible with non-trivial vector spaces. No implicit dtype conversion is done. You can use np.zeros_like(arr, dtype=np.float) to cast a float0 array to a regular zeros array. If you didn't expect to get a float0 you might have accidentally taken a gradient with respect to an integer argument.z^{} does not accept dtype {} at position {}. Accepted dtypes at position {} are subtypes of {}.rc34K|]}|jywrYr0rs rTrlz$naryop_dtype_rule..zs8Qajj8r1) r enumeraterrbrrrrrpr0rr}check_same_dtypes) r6r7rrPrQrrrtypesrsr9 typenamesrs @rTnaryop_dtype_rulerYes Us?+ +Ee_-EE +5!Ega 4::v7K7K L A E ?? ? v}} $dV6qc:D DE ED"4::.II8%88  41aCDD'E($T2E2 u ' ''rVct|Dcgc]}|js|j}}|syt|d|iScc}w)Nrir)rqr)rrrrus rTbroadcasting_shape_ruler[s:#( 74DJJDJJ 7& 7   2T 22 8s55cd}|D]}|j|jjjr1|H||jjk7r/tjd|d|jj|jj}| t n|}|Dcgc]}|j s|j }}|st|tSt|Dchc] }t|c}dk7rHd}t|j|djtttt||Dcgc]%}|j s|jj '}}dgt|dz} t#t%t%|t%|D]\} \} t'fdddDr d| | <)t%| D cgc]\} } tj(| dr| | !c} } sd| | <ht'fdddDr d| | <D]f} | | | | | | <| | | | | | k7s"tj|d djtttt|d t|t| Scc}wcc}wcc}wcc} } w) Nz3Mesh for all inputs should be equal. Got one mesh: z and another mesh: rNz7{}: arrays must have same number of dimensions, got {}.rrc3.K|] }d|k(ywrhri)rjrsss rTrlz-broadcasting_sharding_rule..s &!2a5A: &c3.K|] }d|k(ywrhri)rjr non_trivial_ss rTrlz-broadcasting_sharding_rule..s@}Q1$@r_z. got incompatible shardings for broadcasting: rn)rmeshrrShardingTypeErrorr-rqr8rrrpr}rrrrrrUrror)rrrbrrrurqrsspecs result_specsrr{rrzrar^s @@rTrrs $ azzajjoo&;&; dajjoo5$$A$Hjjoo. 01 1ZZ__d !%  $$#( 74DJJDJJ 7& 7  qs ##& )#e* )*a/ CC CJJtTYYs3E68J/K%LM NN$) 5qQWW1::?? 5% 5#fQi.(,s3;V =>>ka"b &r!"v &&1l1o%(R[KTQ#44Q:qyKm  Q @mAB.?@ @'* Q >A !_ $LOQ+ Q1$((&F99Sc%&789:!=> >  >>* tQ - ..? 8 * 6Ks$,J;>J;-KK'K,$K c|Dcgc]}|js|}}|Dcgc]}|jj}}|Dchc]}|js|j}}t |dkDrt j d||r|n tf\}|r|D]}|jj}t|} |jj|zrt j d|d|t| |zsgt j d|d||j|jj|Scc}wcc}wcc}w)NrNzCAll inputs should be reduced across the same mesh axes. Got specs: z_Inputs cannot be replicated on the same axes that another input is reduced on. Got input spec: z and reduced spec: zInputs cannot be sharded on the same axes that another input is reduced on. Reshard the input which is reduced to be sharded on the mesh axes it is reduced on via `jax.sharding.reshard(inp, jax.P(...))`. Got input spec: r>r) rqrrr?rrrcrr;replicated_axesr) rArparamsrnon_empty_avalsrdr reduced_spec reduced_s flat_specs rTnary_reduced_rulermsh %11Q1/1$3 4q1::?? 4% 4%*8aii!))8,8   >   ,|)+*)  Q **//aq/i  # #i /$$ //0c1DYK QR R 9  )$$ ./0S0CI; PQ Q Q 5::,,Y,? @@/2 48sEEEEEc tt|||||}tt|}tt|} t |||| tt j ||t} tj| | S)N)rQrPrFrGunreduced_rulerH) rrYr[rr2rstandard_vma_rulermr'defbroadcasting) r6r7rrQrequire_same_dtypesrprHrK shape_rulerFrLs rTnaryoprusv(,,@$79*.5*4d;- *d-t--t4#2C E$ 4 +rVc Jtts tdtj|}t j j|r.jt j|jk(r|Sjr#t|tjk(sJjs't|ttt|Stt|jDcgc] \}\}}t j||s|"}}}}t j"j$rt'fd|DsJ|r t||n|}t)|jj+jScc}}}w)Nz7transpose with implicit broadcasting of unshaped valuesc3BK|]}j|dk(ywrNNrq)rjrrs rTrlz_unbroadcast..s2A!#2sr)rr!rprZrqrrrrrrrrQrUrrr enable_checksrrorto_cotangent_aval)rrSx_shaperrbrs` rT _unbroadcastr~s> D+ & M NN HHQK' !!$**g6 mmt{{1~... H ZZ3w<3tzz?:: :  aeCL12 33(Wdjj)AB 0 0)!Va((A.  0D 0 !! 2T2 22 2# 1dA 1djjt/E/E/G/P/P QQ  0s%Fc htj|}tj||r|S|s t ||dSt t ||Dcgc] \}\}}tj||r|"}}}}|Dcgc]}|| }}t t||||Scc}}}wcc}wr%) rZrqrrrrUrrr) target_shaperSr|rrr}r squeeze_shapes rT_maybe_broadcastrs HHQK'   ,7 H  A|R 00(Wl)CD , ,)!Va$$Q*  ,D ,)-.AWQZ.M. GA}5|T JJ ,.s %B( B/c g}t||D]r\}}|j|jk7rAt|jt|jks J||ftjt t t|jt|jz t|j}td|jDrItjtj||tj|j|}nDtjtj|j|j||}|j|u|S)zLBroadcasts HLO values with broadcast-compatible shapes to the same shape. c3PK|]}t|tj ywrY)rr3Valuers rTrlz broadcast_hlo.. s =Z288 $ =rry)rrqrr(dense_int_arrayrrQrr5dynamic_broadcast_in_dimaval_to_ir_type shape_tensorrrr)aval_outrrrrargrs rT broadcast_hlors) #ud# idC zzX^^# _HNN 3 3EdH5EE 3  ! ! uS(3tzz?:C>!B CS JJsO  *rVrc~|j|jc}\}tj||||j|j }||}|r||dt |i}tj|||gS)z9Lowers an elementwise operator to its MLIR equivalent. result_accuracy)rrr(multi_broadcast_in_dimrqr accuracy_attrlower_with_sharding_in_types)r$rrrrhrrrs rT_nary_lower_hlors|  ,, (KX $ $S$(..%-%6%6 8$ D # d >, ?D Q< 3H ==rVcT|\}tj|||t|dfS)Nrct||SrYr)cos_xrs rTrz_sin_lin..s 3q%=rV)rrr )nzsrSrnzs rT_sin_linrs. #" **Q* *BA ( **rVrc0t|t||Sr)rdr rrSrs rTrrsAs1x/H(IrVc t|t|}}t|t|d}t|d}t |t |}}t |t t|}}tt|||ttt||||} } t|| tt|| } } t|t| t|dt| | Srrrs rT _cos_complexrs a$q'Q!F1aL!)q! # q63q6b" 1XuSV}s# S# $c#c#smS*A3&Gs# r3<SWc*b"  72va|4gb"o FFrVctj|jdjtj r$t jtd}|||Sttj|||Sr) rrrrbrZrr(rrrr5cosine)rrSrrs rT _cos_loweringrsW s||A,,b.@.@A ^^L5 AF #q> S!h ??rVr c Btt|t||Sr)rrdrrs rTrrs#c!SX-F&G"HrVrc Tt|tt|dt|SrI)rdr]rrrs rTrrsc!S1vc{5S.TrVrc ft|ttt|dt |SrI)rdrDrarrrrSs rTrrs#s1eCq! fQi,H&IJrVrc xt|tttt |dt |SrI)rdrrDrarrrs rTrrs(s1c%F1aL&)0L*M&NOrVc.t|t|dSrI)r%rrRs rT atan_implrs q&A, rVrc Tt|tt|dt|SrI)rgr]rrrs rTrrss1c&A,q &BCrVr%c ft|t|tt|t|SrY)rdrgr]rrrSr$s rTrrs##aQF1Ivay(A!BCrVc xt|tt|tt |t |SrY)rdrgrr]rrs rTrrs'#aSVSF1I-F!GHrVrc,t|t|SrY)rdrrs rTrr s1d1grVrc,t|t|SrY)rdrrs rTrr rrVr c dt|ttt|t |SrY)rdrDr]rrrs rTrrs!AuSDG-D'E FrVr c dt|ttt|t |SrY)rdrDrarrrs rTrrs!s1eCq 47$;<=rVrc tttt||t |t t||SrY)rdrr]rrgrars rTrrs-s:c$q'1o6As47A8OPrVr(c Vt|tjdt|gSr%)rrZrr1rrs rTrr!sGArxxF1I/F$G#HrVr,chttjdt|t |gSr%)rrZrr1rrs rTrr%s#GBHHR,CSV$L#MrVc tj|stj|sJtj|rtj|rt|tjur>tj|j tj|j gSt |j t|t |j tt|gStj|r]t|tjur!tj|j dgSt |j t|dgSt|tjur!dtj|j gSdt |j tt|gSrY) r&is_undefined_primalrr Zerorr~r(r,r)rrSr$s rT_complex_transpose_ruler)s6   "b&<&@A BB "Qa/1c!f --rVc2t|r t|S|SrY)r r2rRs rTrre:a=QarVc2t|r t|S|SrY)r r(rRs rTrrfrrVr@c Bt|tt|d|S)Ng?)rdrgrrs rTrriss1c&C.#6N/OrVrDc Vt|tt|dt||S)Ng)rdrrgrs rTrrps As6!T?CQK'H IrVrGc Vt|tt|dt|dS)NgUUUUUU?r)rdrr=rs rTrrxs% 3vaS"!5 6!rVrctj|jdjtj rt j||gStj|gSrC) rrrrbrZr1r5rr4rrrSs rT_square_lower_hlorsI s||A,,bjj9 LLA   ++a. rVc Bt|tt|d|Sr)rdrrs rTrrss1c&A,.B'CrVchtj|jtjr:tj|jtj r |jS|j|jk(r |jSt d|jd|jd)Nzthe first argument to pow must have an inexact dtype (float or complex), and the second argument must have an inexact or integer dtype, and two inexact dtypes must match, but got rwz respectively.)rrrbrZrLr1rpr#s rT_pow_dtype_rulers , , 77NWW 77NPWWIU177)>; <'?@ BC aQAuQx() *C QrVc tj|}tj|tjsJt t |t tt|||SrY) rrbrrZrLrrdrr)rrrSr$r#s rT _pow_jvp_rhsr'sN LLO'   7BJJ // / c!S]1-=)>%DEw OOrVcX|j\}}|j|jk7rg|j\}|j|j}t j t j||}|j||g}ttj|||S)Nr)r) rrbrrr5convertr(rrrpower)rrSr$ry_avalout_avals rT _pow_lowerr-s<<.&& \\V\\! IH ]]] 0F D((0!4A ++/+ 0C CA ..rVcttttztzd|}|dkr6t j |tjrtd|d|d|S)Nr=rz>Integers cannot be raised to negative powers, got integer_pow(r)) r;r_int_float_complexrrrZr1rp)rSr$rbs rT_integer_pow_dtype_ruler3s^ )TF]X%=}a P%Uv   3 ##$#Rs!- .. ,rVc ||dk(r t|St|tt||t||dz SNrrN)rrdrr=rs rT_integer_pow_jvpr6s61fR#aVAq\;q!a%;P)Q"RRrVr=r)rFrGc|dk(r t|dS|dk}|r| }d}|dkDr1|dzr||n t||}|dz}|dkDr t||}|dkDr1|rtt|d|S|Sr5)rrdrg)rSr$ is_reciprocalrs rT _integer_powr9s!V Q?a%- A # A1uA#c1+c!GA1u a)a A)6YsA  $>3>rVc|dk(r|}n|dk(rtj||}n|dk(r+tjtj|||}nf|dk(r9tjtj|d|j d|}n(tj td}||||\}|j\}tj|||gS) NrNrMrxrrFrr;) r5rdivider(rrrr9rr)rrSr$rloweringrs rT_integer_pow_loweringr=s!V CAv ,,q! CAv ,,s||Aq)1 -CBw **T((aaA1 EC~~lUCH Ca DCmm)(  + +Ch ? @@rVc Vtt|t|dt||SrC)rrzrr"rRs rTrrs &Ava|!4eAhBrVnotandorxorrWrZc|\}}|\}}t||}t|t|cxurtjur$nn!|tjj |fSt|tjur|t |j |fSt|tjur|t |j |fS|t||fSrY)r]rr rfrom_primal_valuerrqprimalstangentsrSr$xdotydot primal_outs rT_add_jvprKs $!Q*$1ay* $Z4:-- w||55jA AA $Z7<< ' (8(8$? ?? DzW\\! ' (8(8$? ?? s4 &&rVctj|r |jntj|}tj|r |jntj|}t |t jur*t j|t j|gSt||t||gSrY) r&rrrrrr rr~rrSr$rr+s rT_add_transposerNs ++A.166DMM!4D&++A.166DMM!4D& !W  LL ',,v"6 77  #\&!%< ==rVc|jjj|jjj}}|r%|r#||k7rtjd|d||}nA|s|r3|r|sd\}}n |s|sJd\}}tj|d|d|dt }|j |jj | S) NzIlhs and rhs to `add` must be unreduced along the same mesh axes. Got lhs=, rhs=)rr)rrz is unreduced while zi is not. `add` operation does not allow this because there will be implicit communication. Please reduce z$ via `reshard` before calling `add`. unreducedr)rrrRrrcrr)rrSr$x_ury_ur res_unreducedlhs_strrhs_strs rT_add_unreduced_rulerXszz((!**//*C*C$ d t|  " " F& ( ))M t D%gw$ %gw  )'y1)? A BB KM   ,"3"3":":]":"S  TTrVr])rpr r\c|\}}|\}}t||}t|t|cxurtjur$nn!|tjj |fSt|tjur!|t |j t|fSt|tjur|t |j |fS|t||fSrY)rarr rrDrrqrrEs rT_sub_jvprZ:s $!Q*$1ay* $Z4:-- w||55jA AA $Z7<< ' (8(8#d)D DD DzW\\! ' (8(8$? ?? s4 &&rVctj|r |jntj|}tj|r |jntj|}t |t jur*t j|t j|gSt||t|t|gSrY) r&rrrrrr rr~rrMs rT_sub_transposer\Gs++A.166DMM!4D&++A.166DMM!4D& !W  LL ',,v"6 77  #\&#a&%A BBrVrac|jjj|jjj}}|r|rtjd|d||rC|sA||jjj k7rtjd|d||}nU|sC|rA|jjj |k7rtjd|d||}n|s|rJt }|r&|jj |k(sJt }n|jj }|j|jj||S)NzHlhs and rhs to `mul` cannot be unreduced since mul is bilinear. Got lhs=rPzGRHS should be reduced along the same axes LHS is unreduced on. Got lhs= and rhs=zGLHS should be reduced along the same axes RHS is unreduced on. Got lhs=)rRr?r)rrrRrrcr?rr)rrSr$rSrT out_unreduced out_reduceds rT_mul_unreduced_ruleraWsdzz((!**//*C*C$ d   F& ( )) D qzz&&&  " " IaS " ##M Dzz$&  " " IaS " ##MD KM    $ $ 55 5+K##++K   ,"3"3":":{#;#4  55rVrdct||SrYr)rHrSr$s rTrrvs Sq\rVct||SrYr)rIrSr$s rTrrws SD\rVcBt|jt||SrYr~rrdctrSr$s rTrrxs|AFFCAJ'GrVcBt|jt||SrYrerfs rTrrys QVVSBZ @rVctj|rtj|rJt|tjur!tj|j dgSt |j t||dgSrY)r&rrr rrr~rg) cotangentrSr$s rT_div_transpose_rulerk|sh   "2+A+A!+DD D )_ $ LL $ '' Y!2 3T ::rVrgct||SrYrrs rTrrs #a)rVcTttt||t|dS)Nr)rdrr=rs rTrrs#c#a&!nk!R.@ArVrjcztttj|tj||SrY)rrrZrqrs rTrrs'$%5bhhqk288A;%OQRSrVctt|ttt||t t t||SrY)rdrrrgrr5rs rTrrs1CADQOU3s1ay>5J KLrVc Jttj|tj|}t||}t||}t |}t |}t t |||t|t||||}t |||SrY)rrZrqrr(rrzr,)rSr$lax_cmp_pick_xrrxrypick_xs rT_minmax_complex_loweringrus!"((1+rxx{;,|Q'!|Q'! Aw" Aw" "R*nT!Wd1g> R( *& 1 rVzcore.Primitiverlc0t|t|||SrYrd _balanced_eqrrrSr$s rTrrA|AsA'> ?rVc0t|t|||SrYrwrys rTrrrzrVrnc0t|t|||SrYrwrys rTrrrzrVc0t|t|||SrYrwrys rTrrrzrVrqrtrwc |\}} tj|} tj| } tj| j|j} t t |j| j} tj|tt|d||| | g| g\}tj|tt||| || g|gS)NFrrrT) r physical_avalr!rqrbrrQrOr(delegate_loweringr_compare_lower_hlo_unary_reduce_lower) direction reduction_opidentityrrrrSr$aval_xaval_y base_aval_x base_aval_y base_aval_out reduce_axesress rT_opaque_comparison_hlors.&&""6*+""6*+"";#4#4hnnE-eHMM=+=+=>?+   7%y% 8k;/M? L$#    7& h# % ]Oz ;;rVrNEctfd|D}|dk(rt||||S|dk(rt||||Std|d|dj)Nc3rK|].}tjj|j0ywrY)rr!rqrb)rjrrs rTrlz,_compare_lower_hlo_opaque..s-I7;dx~~tzz2Is47rrzHLO comparison z for extended dtype r)r_opaque_eq_hlo_opaque_ne_hlorrb)rrrrrSr$broadcast_avals_ins ` rT_compare_lower_hlo_opaquersI?GII$ #18Q BBD #18Q BB  )$8!9J9J8KL NNrVc|j|jc}\}|dj}tj|||f||j |j \}}tj|tjr|rJt||||||Stj|tjr|rdnd}n)tj|tjrd}nd}tj||||gS)Nr TOTALORDERFLOATSIGNEDr)rrrbr(rrqrrrr~rrZrL signedintegerr) r total_orderrrSr$rrx_dtype compare_types rTrrs,, (KX QK  ' $ $S1a&(HNN%-%6%6 8$!Q w0? $YXxA NN w +#.G gw9#  + +Ch ? @@rVc\t|tjr$t|jtjrJt|tst dt |t|jddx}r||j|}n|jj}|s-tdt|jdt|tj|}t|jj d|j"zk(sJ|j|jk7rDtdt|jdt|dt|jd|j"|j"krYtd t|d |j$d |j"d |j$d |j"d |j"d |j"|j"z }|j$d||j$|d}}||j$k7rBtd t|d |j$d|j$d|d|j$d t|tr|jj d||jj |d} }t| dt'| zk7r+td|j)dd|j$|j+|||jj+|SJ)Nz?can only convert to an extended dtype on an array type,but got convert_to!Cannot convert_element_type from rrYz\can only convert to extended dtype from its representation dtype, but tried to convert from - which doesn't match the representation type rnzdcan only convert to extended dtype from an array of its representation type, but the extended dtype z has a representation shape z (rank z1) while the given representation array has shape z < z).z0 while the given representation array has shape z,, so the shape suffix does not match: given z but required zcan only convert to extended dtype from an array with trailing axes that are not explicitly sharded, but tried to convert from T) short_dtypesz) to an extended dtype with element shape r)rqrbr)rrrrbr!rprrrallow_conversionrr0rrrrrrOrqr str_shortr) rSrrrrep_avalr shape_prefix shape_suffix spec_prefix spec_suffixs rT_to_edtype_abstract_evalrs VV11 2&"6"679 8 A{ # #Awi) **6==,==Z=!!''62}}55   +OAGG,D+EFf% & ( )) ' ' /( x  %% &'HMM*A AA AWW  %%4QWW%=$>d 6 " ##P 8>> * +1 . // VVhmm  77Fv7N6O &x~~&6ghmm_M::;''' 66(#hmm_B  ( )) ffx}}! wwr{AGGABK ,X^^#  77Fv7N6O &x~~&67**+''3!!-nX^^>" $ %% 88,fZZ..K.@  BB5rV to_edtypec@t|tj|SrYrrr)rrSrs rTrrs q$"D"DV"L MrVcZtj||jjgSr)rrrrb)rgrSrs rTrrs!=--b -EFrVc |gSrYrirrS__s rTrrssrVc t|jtjrt|tjrJt|tst dt |t|jjddx}r||j|}n |jjj}|s-tdt|jdt|tj|j}t|jj d|j"zk(sJ|j|k7rDtdt|jdt|dt|jdt|tr,|j%g|j&|j&| SJ) NzAcan only convert from an extended dtype on an array type,but got convert_fromrrrYz\can only convert from extended dtype to its representation dtype, but tried to convert from rrnrqrb)rrbrrr!rprrrrrr0rrrrrrOrrq)rSrbrrrs rT_from_edtype_abstract_evalrs QWWf22 3 4 457 6 A{ # #Awi) **QWW^^^TBB\B#AGGU3ww~~66   +OAGG,D+EFe$ % ' (( ' ' 0( x  %% &'HMM*A AA A ^^u  %%4QWW%=$>d 5 ! ""O 8>> * +1 . // ; 885AGG5hnn5U8 CC5rV from_edtypec@t|tj|SrYr)rrSrbs rTrrs q$"D"DU"K LrVcFtj||jgS)Nr)rrrb)rgrSrbs rTrrs+**2agg*>?rVc |gSrYrirs rTrr s!rVc|j}tj|}tj|}||k(r |jS||kDrg|j||zS|jr|jdnd}||z|k7r-t d|jd|d|d|d|d|d|d ||jddS) NrrNz%Attempting to convert array of shape z from z of size z bits to z , bits but z * z != )rbr itemsize_bitsrqr)rrr old_nbits new_nbitsdim_sizes rT _bitcast_convert_type_shape_ruler smm)""9-)""9-)) ==9 3W]] 3I2 33$+MMw}}R qH)y(  / ?{)I;/[ )-jI;d9+ 7 88 ==" rVcj|j}tj|}tj|}||k(r |jS||kDr5|jj g|jj dS|jj |jj ddS)Nrr)rbrrrrr)rrrrrs rT#_bitcast_convert_type_sharding_ruler!smm)""9-)""9-))   9    " "(F'*:*:*?*?(F(F " GG    " "(8(8(=(=cr(B " CCrVcl|j}tj|tjsltj|tj sHtj|tjs$tj|tj r||k7rt d|d|d|S)Nzlax.bitcast_convert_type does not support bool or complex values unless the operand and destination types match. Got operand dtype=z , new_dtype=z/. Consider using the arr.view() method instead.)rbrrrZr0rrp)rrrs rT _bitcast_convert_type_dtype_ruler.smm)  288,  2#5#56  288,  2#5#56I ++4+] |DFF GG rVr)rrFrGc|j\}tjtj||}tj |||gSrY)rr5bitcast_convertr(rr)rrrrrs rT_bitcast_convert_type_lowerrCsBmm)( D00:GD#  + +Ch ? @@rVcztjtjr%tjtjrntjtjtj f}t fd|Dr tdtjtjr/tjtjs tdtjj}tjj}||kr tdy)Nc3|K|]3}tj|xrtj| 5ywrYrr)rjrr/rs rTrlz3_validate_preferred_element_type..SsH P<=   [! , 8   3Q 728 8 Ps9<zInput type is incompatible with `preferred_element_type`. The compatible combinations of (input_type, preferred_element_type) are (integral, integral), (integral, floating), (floating, floating), (complex, complex.zL`preferred_element_type` must have the same signedness as the original type.zE`preferred_element_type` must not be narrower than the original type.) rrrZr1floatingrrrprrbitemsize)r/r allowed_typesinput_bitwidthpreferred_bitwidths`` rT _validate_preferred_element_typerKs  RZZ0 . < ZZb.@.@AM  PAN PP A BB +r'7'78   4b6F6F G . //88K(11.xx 67@@.( % &&)rVcl|t|tstt|\\}}\}} t fd||fDs d|d|dj } t | t fd|| fDs d| d|dj } t | t|t| k7rd } t | j|| t|t|} } t|t| }} t| t|k7rd |d } t | t|t| k7rd | d } t | t| t|k7rd |d } t | t| t|k7rd|d } t | | | zrd} t | j||| |zrd} t | j| |tfd|D}tfd| D}tj||sd} t | j||tfd|D}tfd|D}tj||sd} t | j||tjj|S)Nc3K|]b}tjtj|dxr3tjtj|jdywrhrZro greater_equallessrO)rjrzrs rTrlz*_dot_general_shape_rule..kO 4VVB$$Q* + Lrwwq#((7K0L L 4A(A+zdot_general requires lhs dimension numbers to be nonnegative and less than the number of axes of the lhs value, got lhs_batch of z and lhs_contracting of z for lhs of rank c3K|]b}tjtj|dxr3tjtj|jdywrhr)rjrzrs rTrlz*_dot_general_shape_rule..rrrzdot_general requires rhs dimension numbers to be nonnegative and less than the number of axes of the rhs value, got rhs_batch of z and rhs_contracting of z for rhs of rank zldot_general requires equal numbers of lhs_batch and rhs_batch dimensions, got lhs_batch {} and rhs_batch {}.zHdot_general requires lhs batch dimensions to be distinct, got lhs_batch rnzHdot_general requires rhs batch dimensions to be distinct, got rhs_batch zTdot_general requires lhs contracting dimensions to be distinct, got lhs_contracting zTdot_general requires rhs contracting dimensions to be distinct, got rhs_contracting z~dot_general requires lhs batch dimensions to be disjoint from contracting dimensions, got lhs_batch {} and lhs_contracting {}.z~dot_general requires rhs batch dimensions to be disjoint from contracting dimensions, got rhs_batch {} and rhs_contracting {}.c3<K|]}j|ywrYryrjrrs rTrlz*_dot_general_shape_rule..:1#))A,:c3<K|]}j|ywrYryrjrrs rTrlz*_dot_general_shape_rule..rrzidot_general requires lhs batch dimensions and rhs batch dimensions to have the same shape, got {} and {}.c3<K|]}j|ywrYryrs rTrlz*_dot_general_shape_rule..F ! Frc3<K|]}j|ywrYryrs rTrlz*_dot_general_shape_rule..r rzRdot_general requires contracting dimensions to have the same shape, got {} and {}.)rr8rrrorOrprr}rrrr_dot_general_shape_computationrq)rrrrrrlhs_contractingrhs_contractingrrrslhs_contracting_set lhs_batch_setrhs_contracting_set rhs_batch_setlhs_batch_shaperhs_batch_shapelhs_contracting_shaperhs_contracting_shapes`` rT_dot_general_shape_ruler-esj}&M ?QRc?d<$?O&) !{! %C C.3y>) !{! %C C. _!55 ""1!2! 5C C. _!55 ""1!2! 5C C.=( NC CJJy/: ;;=( NC CJJy/: ;;: ::/: ::/ $ $_o F 4C CJJ@ AAFoFFFoFF $ $%:O PPrVct|\\}}\}}tfd|D}ttt|t|z}t|} d} t |t rt|j } ttt|t|z| z} t|| } || z| zS)Nc3(K|] }| ywrYri)rjrrs rTrlz1_dot_general_shape_computation..s6qil6ri)rrr tuple_deleterrr) rrrr#r$rr batch_shapelhs_contract_or_batchlhs_tensored_shape rhs_grouprhs_contract_or_batch_or_grouprhs_tensored_shapes ` rTr"r"s?QRc?d<$?O& >>rVclt||D]%\}}| | ||k7stj|yrY)rrrc)lhs_specrhs_specrslrs rT_check_specs_matchr=s<(H%(da}16  " "3 ''(rVcNjjjsjjjspjjjjk7rCtjdjjdjj|t |t sJ|S|\\}}\}} tfd|D} tfd|D} tfd|D} tfd| D} d| d| d }t| | |d | d| d }t| | |t| | D]%\}}| | tjd | d | jjjr7jjjsjj}njj}tjjjj||S) Nz0Mesh of both lhs and rhs should match. Got lhs: z and rhs: c3PK|]}jj|ywrYrrrs rTrlz-_dot_general_sharding_rule.. Ms||003Mr|c3PK|]}jj|ywrYr@rs rTrlz-_dot_general_sharding_rule..rAr|c3PK|]}jj|ywrYr@rs rTrlz-_dot_general_sharding_rule.. A!**1-Ar|c3PK|]}jj|ywrYr@rs rTrlz-_dot_general_sharding_rule..rDr|zhdot_general requires lhs batch dimensions and rhs batch dimensions to have the consistent sharding, got rwrnzMdot_general requires contracting dimensions to have consistent sharding, got zContracting dimensions are sharded and it is ambiguous how the output should be sharded. Please specify the output sharding via the `out_sharding` parameter. Got lhs_contracting_spec=z and rhs_contracting_spec=) rrbrrrcrr8rr=r!_dot_general_sharding_computationr)rrrrrrr#r$rrlhs_contracting_specrhs_contracting_speclhs_batch_specrhs_batch_specrsr;r<rbs`` rT_dot_general_sharding_rulerKs ,,   ! !#,,*;*;*A*A ll3<<,,,   LL   j):):(; = >> lM 22 2 ?P<$?O&/?u  ! #^^S9 -.e4H3I L#)+?E&(<=Gda}  " " ('((C.B-D F GGG \\S\\%6%6%<%< <<  D <<  D * ll**,=t EErVcF|\\}}\}}tfd|D}ttt|t|z} t| } ttt|t|z} t|| } t|t || z| zS)Nc3(K|] }| ywrYri)rjrr9s rTrlz4_dot_general_sharding_computation..s4QXa[4r0)rrr1r8r) r9r:rrbr#r$rr batch_specr3lhs_tensored_specrhs_contract_or_batchrhs_tensored_specs ` rTrFrFs?P<$?O&lhs or rhs passed to dot_general cannot be unreduced. Got lhs=r^c3PK|]}jj|ywrYr@rs rTrlz._dot_general_unreduced_rule.. O!!2!21!5 Or|c3PK|]}jj|ywrYr@rs rTrlz._dot_general_unreduced_rule..rTr|zlhs and rhs contracting dims should be sharded identically when out_sharding provided to dot_general mentions unreduced_axes. Got out_s=z, lhs_contracting_spec=z, rhs_contracting_spec=z[out_sharding's unreduced axes should be equal to the contracting specs. Got unreduced axes=z and contracting spec=)rrrRrrcrr;r) rArrrrr#r$rrGrHrrls `` rT_dot_general_unreduced_rulerVsL\\  CLL$5$5$?$?  ISFK 6   ZZ,=)&_o O OO O OO33  " " 1023$" $ & '' ))=>Pq!-PIP zzy33  " " ((- (<(<'=>34 6 77 , Qs D5D5c |SrYri)rArrrrs rT_dot_general_reduced_rulerXs ,rVcjt|tfdttDS)Nc32K|]}|vs|ywrYri)rjridx_tups rTrlztuple_delete..s@!!4-s1v@s  )rrrQr)r\rkr[s` @rTr1r1 s% S$ @uSX@ @@rVzlax.dot_generalr;c|t|tst~d}||j||j} }|| kDr |j} n^| |kDr |j} nL|j|jk7r't |d|jd|j|j} t|t t f} t| || S)Nctj|tjr t |n|}tj|tjtj|tj rtj |jndtj|tj rtj |jndt|tj|tj fSrA) rrrZrrr rOmaxexpnmant _bit_widthr)dtrs rTtype_propertiesz0_dot_general_dtype_rule..type_propertiess!,,R1C1CD B"A   b""4"4 5&,&7&72;;&GFLLO " "R&,&7&72;;&GFLLO ! !R qM!!!R%7%78 8  ::rVz argument type error: r)check_bit_width)rr8rrbrprLr[ _maybe_upcast) rrrrrrrrclhs_proprhs_propr6 has_algorithms rT_dot_general_dtype_rulerisj}&M :'syy1?3993MH( 99L(99L yyCII 4SYYKr#))M NN99LY7I(JK- |%;+8'8 ::rVcNtj|tjrtj|j Stj|tj rtj|j S|tjdk(ryJ|)NrrN) rrrZrLrObitsr1r[rb)rzs rTrara.sl q"**%fll1o.B.B'B BJJ' Q0D0D)DBHHV QaurVc|||k(r|S|rMtj|tjs)t |t |krt d|d|d|S)Nzd`preferred_element_type` must not be narrower than the original type, got preferred_element_type of z for result type of rn)rrrZr rarp)r6rrds rTrere4sp$,, f// bkkJ'(:l+CC D-..B#nA' (( rV)swap_ansc|\\}} \} } |jj} tt| || } ttt j|| | }|rt | || \}}}nt | | |\}}}||f|| ff}t t j|t j| }t | | z|z}t j|}|jjjtfd|D}jjj|}t||||||}t|t|}|j |jj k7r5t#||jj |jj$}|S)Nc3<K|]}j|ywrYr)rjor>s rTrlz-_dot_general_transpose_lhs..Qs9arwwqz9r partitionsrrrr)rrO remainingrQrZ ranges_likerrargsortr{rrrrrrPrbrr)rrSr$rrrrrm x_contract y_contractx_batchy_batchx_ndimx_kepty_kept ans_batchans_yrrx_contract_sorted_by_y unsorted_axesout_axes inverse_specr{dot_general_outx_barr>s @rT_dot_general_transpose_lhsrAs2C.:z.Wg 66;;& U6]J 8& U2771:& G <& %gvv>Iua%gvv>Iq% &/Iw/ 0$ BJJz4J KLw-&(+AA- ZZ &(vv!**"9=99, yybggnn n=y>"1di7M-/1/ OU8_ 5% [[AFFLL !%qvv7G7G HE ,rVc N|\\}}\} } ||f| | ff} t|||| |||dS)NT)rrrrrm)r) rrSr$rrrrrwrxryrzswapped_dimension_numberss rT_dot_general_transpose_rhsr[sO2C.:z.Wg *J7'79KL #q!8I1  rVc ||\} } ||\} }ttj| tj| f| |f|\}}tj| }tj| }t |||}t |t |}|tj|||}|| | ||| |}||fS)Nrs) _dot_general_batch_dim_numsrZrOrqr"rDrr'r) unpack_args unpack_dims invoke_primrrrrrrrrrrlbdrbdnew_dimension_numbersresult_stack_dimrrrresult_batch_dim batched_outs rT_dot_batch_rulerfs &(#s  $(#s,G wws|RWWS\"S#J-))hhsm)hhsm)/ 9F[\,&'7\9JK11.bump_dimss% b..tQ78 99rVrr)rrrrrrQrsumrZrrrtrr)ndimsrrrrrrrrrr is_ragged_dotrrrz lhs_tensor rhs_tensorrs rTrrs"(H(#s CO+ +9KL]9^6< 6I.0IJ-: #Y$s)"s"9c22I9c22I\3/L\3/L S SS[#8_Ci'A\,ACJC9~C C0H,I(JJ)S)I\3/L S SS[ (O  6C  2 2  J!3|#44C C 89:;)S)I\3/L5(,7)Y9OP53'  3 3S '  2 2C   0 00GCs*GcJ|jjDcic] \}}| || }}}|jd\\}}\}} t|t|ft|t| ff|d<tj|j |||Scc}}w)Nrr)rhrrrrr) rrrrrprinted_paramslhs_contrhs_contrrs rT_dot_general_pp_rulers&)ZZ%5%5%7ITQ1=AqDI.I14y/IJ!tc!f%J JrcTt|ttfsy|j||SrY)rrLr[rX)rrVrWs rTdot_algorithm_attrrs( I .@A B   ' ' 9 ==rVct|tr#|j|j|jfSd}|||j }|||j }|||j||}|||fS)Ncv||Stj|ttj|vr|S|dSrC)rZrbr)r/ target_dtypess rTmaybe_convert_dtypez8get_algorithm_compute_types..maybe_convert_dtype+s;  xx BHHm <<   rV)rrLrMrNrOrjrlru) algorithmrVrW out_dtyperout_types rTget_algorithm_compute_typesrs  <($$$$##  ")Y-J-JK)!)Y-J-JK) 11)YG( Ix ''rVcBt|tr>tjj ddt dt |jSt|trAtjj |j|j|jdSy)Nrr TOLERANCE)rrrmode) rrr5ResultAccuracyAttrrrrrrrrrrs rTrr:s{,'  ! ! % %c3AHMM8J KK(I&  ! ! % % ]] ]] ]]  & 'rVc d}j^}}}|j|j} } j\} | } i} t|tt fr|dk(r||t j t jt jt jt jt jt jhvrtd|dfd}t|| | | j\} } }|||| }|||| }| tj | j"|} |t j k7r:dt%|| | i} n)| | k7r#|dk(rd}|| r || s t'j(||tj |j"| j}t'j(||tj |j"| j}n|| | st'j(||tj |j"| j}t'j(||tj |j"| j}||| | fS) Nctjtjtjtjtj tj tjf}||vxr||vSrY)rrorprqrrrrr) _lhs_dtypes _rhs_dtypesrs rT_is_fp8_mixed_precision_matmulz=_handle_dot_precision.._is_fp8_mixed_precision_matmulFs\&&(:(:((&*@*@$$f&8&8'')J * $ B )BBrVcpuzThe precision 'z(' is not supported by dot_general on CPUc||j|k(r|Stj|j|}t j |||SrY)rbrr!rqr(r)rr target_dtyperrs rTrz2_handle_dot_precision..maybe_convert_dtypedsJ  !3!3|!C   l00, ?d   c7L$ ??rVrtpuctj|tjxs$tj|tjSrY)rrrZr r1)rbs rTrz'_handle_dot_precision..}s4f//BKK@@$//BJJ?rV)rrbrrrLr[rrcrrhrgrrrrrr!rqrr(r)rrrrplatformrlhs_avalrhs_avalrrVrWraccumulation_avalalgorithm_kwargraccumulation_dtypehandleds` rT_handle_dot_precisionrEsMC<<(Hq!Y)mm)(/ L*<=> 5Y""$6$B$B&&(:(F(F((*<*M*M++ /  I;&N O QQ @ 0K9i09,Iy, c8Y 7C c8Y 7C%**8>>;MN&... ))Y JoI U A "wy'9  c8!%!1!1(..(..!QS#  c8!%!1!1(..(..!QS#.iC  c8!%!1!1(..(..!QS#  c8!%!1!1(..(..!QS# c$o 55rV)rc~t|||||\}}}} |\\} } \} } tjjt | t | t | t | }tj t j||||fdt|i| }|j\}t j|||}|j|jk7rt j||||}|gS)N)lhs_batching_dimensionsrhs_batching_dimensionslhs_contracting_dimensionsrhs_contracting_dimensionsprecision_config) rr5rrrrr(rrrrrbr)rrrrrrrrrrr#r$rr dot_dnumsr rs rT_dot_general_lowerrs 1F 3Y2.#s @Q<$?O&  ) )*rVcTtt||f\}}tt|||}|xtj k(r||d|j |zSxtjk(r||d|j |zStjk(r|d|j |SyrY) rrrtrQrrrrr)rr ragged_dimrcontract noncontracts rT_ragged_dot_prefix_dimsrsuh/0/%%+x7+ , , , [!@;#4#4Z#@A AA ) ) ) X:z :; ;;  # # ,U[[, -- $rVc fd}t|jdk7r td|jd}||jddt j|} |j \\} } \} } |jdk(r td|jdk7r|t | j|| | }tfd|D}||jd fz }tj|j|std |d |jd |jd }|j}| xxtjk(rnxtjk(rnnt|dk7rtd tjk(rwt|dk7r td|d}|||jdd|| vs|| vr td|j||k7rtd|d |j|d t!||||d}| tjk(r|f|z}|S)Nc N|dks||k\rtd|d|d|d|d|d y)Nrzragged_dot_general requires zC numbers to be nonnegative and less than the number of axes of the z value, got z for z of rank rn)rp)dimrdim_namearg_names rT_check_in_rangez7_ragged_dot_general_shape_rule.._check_in_rangesO Qw#+  ( 355=J?U8*IdV1 6 rVrNz=1.c3<K|]}j|ywrYryrs rTrlz1_ragged_dot_general_shape_rule..s@qciil@rrz#expected group_sizes to have shape z, got rnzoragged_dot_general requires zero group dimensions in the rhs when lhs ragged dimension is contracting or batch.zhragged_dot_general requires exactly one rhs group dimension when lhs ragged dimension is noncontracting.zrhs group dimensionrzmragged_dot_general requires rhs group dimension numbers to be distinct from contracting and batch dimensions.z(expected rhs group dimension size to be r)rrrprOrrrrrqrrrrrrrr-)rrrrrrrrrrr#r$rr prefix_dimsexpected_gs_shape num_groupsrhs_group_dims rhs_group_dim out_shapes` rT_ragged_dot_general_shape_rulersy % ; ;<A F 0EEaH..#((,BEJ #(($@ A$#88=$?O&>) chh ?K@K@@+++B/11  & &{'8'8:K L  /  vk&7&7%8 ;   $*0DD. F ) ) ),FM,F,F F ^  ! A    , , ^  ! ;  %Q'mmSXX/DeL ) #}'G >   = !Z / 6l&=!9 :! =  &  43 ) ] - -- )I rVc tj|jtjs t dt |||j||ddS)NzLragged_dot_general requires that group_sizes.dtype is subtype of np.integer.zlax.ragged_dot_general)rrrrr)rrrbrZr1rprir)rrrrrrrs rT_ragged_dot_general_dtype_rulerCsZ   ;,,bjj 9  6  !  4JJ3 # rVcR| td|\}}}|\} } } t||||||} t| tjurt| |||||n t | } t| tjurt|| ||||n t | }t | |}| |fS)N#Unimplemented group_offset support.rrr)rrrr rrr])rFrGrrrrrSr$gsdxdyrrJdx_outdy_out tangent_outs rT_ragged_dot_general_jvp_ruler ]s  C DD (!Q)"b!"#?3 *& b % 'C!7  *  * b % 'C!7  *  FF#+ [  rVc J tdj\\\tj|r|jj nt j |}tj|r|jj nt j |} tt|jtt| t|\d|dk(xr| dk(xr tk(f d} f d} fd} tj|rdn!| |r t|n|| |j} tj|rdn| ||| |j}| |dfS)Nrc:td|d|jdS)NzUnimplemented z for ragged dot general in mode rn)rr)fn_nameragged_dot_modes rTrz4_ragged_dot_general_transpose_rule..s)3Fwi?   a!4rVrMrxc xtjk(rt \}}}r n/t|f|fft  j zg}t tj tj}t  z|z}||fSxtjk(rnxtjk(rnfS d)Nr grad_x_dims) rrrurrrrrZrrvrr)r~rrrrr_is_basic_ragged_dotrrr unimplementedryrwr|rzrxy_groupr}s rTrz7_ragged_dot_general_transpose_rule..grad_x_dimss  .= . .)'66B 1e$ )*(-vG8L&ML6<<#??'&-  "& GGJ : 6 7" W .1GG    ,= + +.Hm.H.H H   IM400rVc xtjk(rzt \}}}t |f |ffgg}t t j t j }t t z|zz}||fSxtjk(rnxtjk(rnfSd)Nr grad_y_dims) rrrurrrZrrvrr)r~ans_xrry_contract_sorted_by_xrrrrryrwr|rzrxrr}s rTrz7_ragged_dot_general_transpose_rule..grad_y_dimss  .= . .)'66B 5!($*E?Wi4H"I#1"2!#  "& GGJ : 6 7"  MDM ),B BV K    ,= + +.Hm.H.H H   IM400rVc |\}}t|| | }t|ttj|}|j |j k7r!t ||j |j}|S)N)rrr)rrPrrZrvrbrr) rrdims_fnrrrragged_dot_general_outr rrrrs rT_ragged_dot_gradz<_ragged_dot_general_transpose_rule.._ragged_dot_gradss!)D-/ sK!7#%-uRZZ 5N/O PF ||tzz!$VTZZHf MrV) rrr&rrrOrZrtrQrrrrU)rgrSr$rrrrrr{y_ndimrrrry_barrrrrryrwr|rzrxrr}s ````` @@@@@@@@@@@rT"_ragged_dot_general_transpose_rulers C DD1M1c1c.:z.Wg003166;;&003166;;& U6]J 8& ( = =' U6]J A&1 *$- kN A+N &*M M .&    " B4H-a0a'FF $   " Ar; 7 t rVc|\}}}||fSrYri)rrrrs rT_ragged_dot_batch_unpack_argsr s+#sA srVcPtd|Ds td|\}}}||fS)Nc3&K|] }|dk( ywrhri)rjrs rTrlz0_ragged_dot_batch_unpack_dims..s ,#SAX ,rmz(ragged_dot vmap over any dim but 0 - NYI)ror)rrrrs rT_ragged_dot_batch_unpack_dimsr#s1 , , , H II+#sA srVc&~t||||||S)Nr)r)rrr new_ragged_dot_dimension_numbersrrrs rT_ragged_dot_general_invoke_primr&s&   #C3  rVc tt|d}ttt|||||||d \}} t |dj dz |r| dz } || fS)NrMrrrN)rr&rr r#rrO) rrrrrrrinvokerrs rT_ragged_dot_general_batch_ruler)sx 2LO D&"1## 43 #+LO00148: & &&rVrr)rGcyr%rirs rTrrAr(rVc | tdd dd fd dfd}t|j|\}} |j\\} } \} } t ||j| | | }t t ||}|jdk(r't||Dcgc]}|j|c}}|xtjk(rW|j}t|dk(sJ|||| |g||| dgzt| |dgzf| | ff Sxtjk(rq| | j| }t ||j|| | }|||| |g|||||g|| | fdg| zdg| zff Stj k(r||||j Sycc}w) Nrc ddlm}|jdk(sJ|j|jz}t ||t t dt|}t|j||dz}|j|}tt|dd|ddgd}t ||d}t ||d}t||k||k}t||t|}|S)Nr) control_flowrNrr!r) jax._src.laxr-rOrqrrrQrrrbcumsumr%rrMr) rSrrr-rqr group_ends group_startsmasks rTragged_to_densez1_ragged_dot_general_impl..ragged_to_densePs) 77a<< HHqww EE4aU(<#=>A BHHeSU 3D$$R(J BQCR)L"*eT:J#L%>L |t+TJ-> ?DtQq "A HrVc |s t|S|^}fd}tj||g|Dcgc] }|| c}dfScc}w)N)rc|k\r|dz S|SrIri)rzx_axiss rTrzK_ragged_dot_general_impl..batched_ragged_to_dense..esa6kQUqrVr)in_axes)rrvmap)r x_in_axesrestdecraxr7batched_ragged_to_denser4s @rTr>z9_ragged_dot_general_impl..batched_ragged_to_denseas\  _# ..MFT 0D 88S F,E"T"X,EF  ,EsAc2|Dcgc]}|dz c}Scc}wrIri)rrzs rTrz*_ragged_dot_general_impl..ksd+q1u++s c|g|||}|dgztt|j|z}t|t j |SrC)rtrQrOrPrZrv)rSrrrexpanded unsorted_dimsr>incrs rTexpandz(_ragged_dot_general_impl..expandrs[2&s2T21b9HJ!$tIeAFFmT,J'KKM Xrzz-8 99rV)rrrNr)r)rSr<rr<rr)r:r)rrrOrrrrrrqrrrrrrrr)rrrrrrrrDrr l_contract r_contractl_batchr_batchl_prefix _dot_generalrrrhs_ragged_dimr_prefixr>rCr4s @@@rT_ragged_dot_general_implrMDs C DD " ,$: 2 hh,$#88/:z.Wg% CHHngz(3, K)I1#))A,)IJK , , ,3HHn  A %% %  nk =H = J1#%tJ'7>!;L:M'MNG}g&  * ) )!*"2"2>"BCn( chhh nk =H = nk =H =Jj!12sT']"QC$w-$78   # #  8NN $7*JsG )rrc >| tdtjjsNt j t d||||||||} |j\} t j|| | S~t|||||\}}} } |j\\} }\}}tjjt|t|t| t|t|jt|j }tj"t j$| ||||t'|} |j\} t j|| | } | j(| j(k7rt j*|| | | } | gS)NrFrr)rrrrrr)r)rr)jax_ragged_dot_use_ragged_dot_instructionrr(rrMrrrrr4rrrrrrrrrbr)rrrrrrrrrr rrrr#r$rrragged_dot_dnumss rT_ragged_dot_general_lowerrQs C DD  9 9 ? ? MT^^4u M S#{%A5! F--KX  , ,S&( CC#8 3Y$ #s q#88=$?O&.sC + - -gmmA.>/0%8LQ8O2P.QS +s58zbroadcast_in_dim operand dimension sizes must either be 1, or be equal to their corresponding dimensions in the target broadcast shape; got operand of shape {}, target broadcast shape {}, broadcast_dimensions {} c3FK|]}tj|ywrY)r replace_tracer_for_error_messagers rTrlz/_broadcast_in_dim_shape_rule..s N1d33A6 Nrz^broadcast_in_dim broadcast_dimensions must be strictly increasing; got broadcast_dimensions {}) _check_shapelikerZrOrrpr}rissubsetrQrorrqr)rrqrr operand_ndimrss``` rT_broadcast_in_dim_shape_ruler[sx%w6%'=')!,S-.. LC CJJ3\B CCZ, UC CJJ|SZ8 99 ! " + +Cc%j0A,B C BC CJJ3\5I JJ  +L) + + # CJJ N NN #% && 3s+?'@#AA !U62F+G%HH )C CJJ34 55 ,rVc||St|}t|jj}t t |Dcgc]}||vr t |nd}}t |dJ|jjjr tn|jj}|jj||jjj|Scc}w)Nrq)rbr) riterrrrQrnextrbrr-r) rrqrrbds orig_specrrrbs rT_broadcast_in_dim_sharding_ruleras  O !#7##(())=B3u:=N Ocd9ot3 O( O i  && &!(!1!1!6!6!.( TQggaj  rrN) r^rrZrqrrrOrr' bdim_at_frontr) rrrhr^rSr`min_bdimx_bdimmax_bdimrs rT_clamp_batch_rulers+#q#)(FH  Sz%B  $#8# xx} 4rxx}4 \\#q# & ..  * * \\#q# & ..  * * S!''H: 6c S!''H: 6c \\#q# & .. wws|qRWWS\Q.63E <<Q $f ,,79xx}sHd3##79xx}sHd3##13!hQ-!!WWS\Q2771:> C !CWWS\Q2771:> C !C" " 773<1 *bggcl*  3! -C" " 773<1 *bggcl*  3! -CWWS\BGGAJ 771:?&BGGAJ&?!SYYA c1c "A %%rVc jttt||t|||t |SrYrrMrrrrr^rr`s rTrrs. RW-r#s|<F7O %rVc jttt||t|||t |SrYrrs rTrrs/ R-r'3/?@F7O %rVcBtt|||t|SrY)rrrrs rTrrs C!1fWo 6rVc  |jd |s d}t|td|Ds7d}td|D}t|j t |t |Dchc]}|jc}dk7r2d}t|j djd |Dd cxkr|d jksOnd }t|j dj|Dcgc]}t|jc}|Dcgc]$}|jd |j dzdz&}}|dd |ddk7rSd }|Dcgc]}|j}}t|j djtt|t fd|D}|d j}|d |fz| dzdzScc}wcc}wcc}wcc}w)Nr!z0concatenate expects at least one operand, got 0.c3<K|]}t|tywrYrr!)rjrs rTrlz*_concatenate_shape_rule..s F'Z - Fz2All objects to concatenate must be arrays, got {}.c3BK|]}t|tr|ywrYr)rjr$s rTrlz*_concatenate_shape_rule..s GR:b++Fb GsrNzGCannot concatenate arrays with different numbers of dimensions: got {}.rc3FK|]}t|jywrYrrqrjrps rTrlz*_concatenate_shape_rule..s(H!QWW(Hrrz@concatenate dimension out of bounds: dimension {} for shapes {}.rzCannot concatenate arrays with shapes that differ in dimensions other than the one being concatenated: concatenating along dimension {} for shapes {}.c3<K|]}|jywrYry)rjrpr!s rTrlz*_concatenate_shape_rule..s91AGGI&9r) poprpror^r}rrrOrrrqrr) r#rrsr$rrpru concat_sizeex_shaper!s @rT_concatenate_shape_rulersjj%)  C G8 G GB CJJtBx( ))h /7',, /0A5 SC CJJtyy(Hx(HHI JJ i *(1+** * LC CJJy$))84TaS\4T*UV WW# % MM*9 % ikl(C C %& % CR[F12J )C,4 4gmm 4F 4 CJJy$))CV4D*EF GG999+ a[  ( *9  .)A+,1G GG# 0 5U % 5s4G,?G1.)G6*G;cB|Dcgc]/}|jjjr$|j1c}stjSt fdDs0dj d|D}tjd|dScc}w)Nc3.K|] }|dk(ywrhrirjr non_empty_ss rTrlz-_concatenate_sharding_rule..s 6QQ+a. 6r_rc3FK|]}t|jywrY)rrrs rTrlz-_concatenate_sharding_rule..s5q3qzz?5rz:All operands should have the same sharding. Got shardings r)rrbrrrrorrc)r#rrpr^rs @rT_concatenate_sharding_rulers%-KQZZ__5J5JK+   % % '' 6+ 6 6 5H5 5B  DRDI KK QLs %BBcl|Dchc]B}|jjjr |jjjD}}t|dkDrt j d||r|n t f\}|j|jj|Scc}w)NrNzKAll operands should be reduced along the same mesh axes. Got reduced specs r>r)rrr?rrrcrr)rAr#rrp reduced_specsrks rT_concatenate_reduced_rulers$A (?(?::??**A-A!    " ##!.}IK>*) 5::,,Y,? @@AsAB1c8tdg||djS)Nr%r)rVrb)r#rs rT_concatenate_dtype_rulersM-H- !  rVc|Dcgc]9}tj|r|jjn |j;}}t |t j urD|Dcgc]8}tj|rt j |jnd:c}St|tfd|DScc}wcc}w)Nc3(K|] }| ywrYri)rjrqr!s rTrlz._concatenate_transpose_rule..sGu% *Gr0ro) r&rrrqrr rr,r)rr!r#rpoperand_shapess ` rT_concatenate_transpose_rulers%'%'$:$:1$=AFFLL177J'.' !W  %'$:$:1$=GLL 4 G  EGGG !! ' s >C%=C ctdt||D}tdt||D}t||Dcgc]\}}|tj||dnft ||ft j |jj|gt j |jj}}}t||dzdfScc}}w)Nc3DK|]\}}||j|ywrYryrjr$bdims rTrlz*_concatenate_batch_rule..s)#T!hhtn#rc3~K|]5\}}|.tj|jj|7ywrY)rrrrrs rTrlz*_concatenate_batch_rule..s=Q"dt?OmmB((--d3Qs;=rrrrN) r^rr'rmrrrrrrr%)rrr!rrr$rr#s rT_concatenate_batch_rulers #Sz-J# #$ Q!, ;Q Q$ ", ; ="d 150@hD!,tgDMM",=,F,F,M,M>dmmB/88==>-N-@AA=(= Xy1} -q 00 =sB C&cRtfd|Dr t|gSt)Nc3xK|]1}t|jttjf3ywrY)rrqrrZr1)rjrr!s rTrlz(_concatenate_pad_rule..s2   AGGI&bjj(9 : s7:)ror%r)rrr!r#s ` rT_concatenate_pad_rulers.   ) , -- rVr%rEc|j\}tj|tj|}tj |||gSrY)rr5r%r(i64_attrr)rr!r>rrs rT_concatenate_lowerr.s>mm)( DMM)45#  + +Ch ? @@rVc g}t|j}td|Drtdt||j|t j |k7r:tdt j |d|dt|j|D]!}|||<|j t|#|S)Nc3&K|] }|dk ywrhrirjrs rTrlz$_split_shape_rule..8s1Qrmz/Sizes passed to split must be nonnegative, got z Sum of sizes z must be equal to dimension z of the operand shape )rrqrrrZrrr)rr(r)rurqrs rT_split_shape_ruler5s & w}} % 7U }E GG ]]4BFF5M) bffUm_$@GGMM*+- .. dE$K MM%,  -rVc4|jft|zSrY)rbrr+s rT_split_dtype_rulerDs -- CJ &&rVc4|jft|zSrY)rrr+s rT_split_weak_type_rulerGs    E **rVc.tj|sJtd|Dr tj|j fS|Dcgc]/}t |tjur|jn|1}}t||fScc}w)Nc3RK|]}t|tju!ywrYrr rrs rTrlz(_split_transpose_rule..Ls5QaGLL 5%'r.) r&rror rrr instantiater%) cotangentsrr(r)rs rT_split_transpose_rulerJs   (( (5*55 << % &&#%$(7gll#: A%*% Z4 0 11%s4Bch|\}|\}|ft|z}t||||k\r|dzn|}||fS)NrNr')rr,)rrr(r)rr new_bdimsrs rT_split_batch_rulerRsD (' %$gE ") gUTT\tL# irVc r|j\}dg|jz}t|j}d|jz}g}|jD]c} ||| j|z||<t j ||| |||} |jt j|| | ||||<e|S)Nrr) start_indices limit_indicesstrides) rrOrrqrr(slice_oprr) rrSr(r)rrrroutsrrs rT _split_lowerrYs LL'&# #-v||$- 6;; ' $--.h'-t0DDM$ --Q &3W FCKK11#sHEF'-M$ . +rVcrt|||}|Dcgc]}tj||dc}Scc}w)Nr'r,)rr+#_get_sharding_for_varying_out_shape)rr(r) out_shapesout_shs rT_split_sharding_rulergsA!DA*" $  5 5fgw O $$ $s4chtjd|}t|||}|gt|zS)Nr,r')rrqrr)rr(r)out_vmars rT_split_vma_rulerns3  " "7G 4' DA* S_ $$rVr,c|j|jk7r1d}t|j|j|jt||S)Nz@pad operand and padding_value must be same dtype: got {} and {}.)rbrpr}r/)rrrrss rT_pad_dtype_ruler~sF ]]m))) LC CJJw}}m.A.AB CC Wm ,,rVctj|dk7r!tdtj|tj|}t |tj|k(std|d|t d|Dstd|t dt||D}t d|Dsd |d |d |}t||S) Nrz.s 21aQ!V 2szKinterior padding in padding_config must be nonnegative, got padding_config c3hK|]*\\}}}}||ztj||dzz,ywrx)r dilate_dim)rjr;hrrzs rTrlz"_pad_shape_rule..s<D!YaAQAE22Ds02c3&K|] }|dk\ ywrhrirs rTrlz"_pad_shape_rule..s $Q!V $rmzADimension size after padding is not at least 0, got result shape z, for padding_config z and operand shape )rZrOrrqrrorr)rrrop_shaper rss rT_pad_shape_rulers WW]q TBHH] 2 2 ++9*:< == D%(%BD D& $V $ $%h&;N;K   ,C S/ -rVcLt|||}tj||dS)Nrpadding)rr+r)rrrrs rT_pad_sharding_rulers/g}-;=)  4 4) %%rVc ttjurptj|rtj|j nd}tj|rtj|j nd}||gSt j|\  fd} fd}tj|r|nd}tj|rt|||nd}||gS)NcTt|ttjSrY)rrrQrO)rSrs rTrz _pad_transpose..sjDqvv$78rVc xttjtjtj}t tj dj |}tj|tj|jtjdS)NrrN) rFrZnegative zeros_likerrrbr+rrqr]) unpad_configunpaddedrinteriorrrs rTt_opz_pad_transpose..t_ops|bkk"or{{2 mmH57lQQWW-|2BH 8E0009tI020F0F}0USq5+ ,[_F V rVc|\}}|\}}|d}t||j|f}t|}|j|d|t ||||fS|dk(sJ|t |t ||}t t |dtjd|}t||j|f} t||| |fS)NrrrrTF) rrqrrrrrrZr0rr) rrrrrrnpadding_value_bdimrSr3broadcasted_paddings rT_pad_batch_rulers''=%/","L-"5"56H"I!KLG'. i0 w ~ 6 DD q 4"44  '5>>2! Ywbhh / G$(*6: a, -| ;;rVrc |j\}tj|\}}}tj|||||||}tj |||gSrY)rrrr(rr) rrSrrrlowrErrs rT _pad_lowerrsTmm)( N3#tX h=#tXF#  + +Ch ? @@rVc|jSrYrrs rT_squeeze_dtype_ruler  rVc@ttj||SrY)_compute_squeeze_shaperZrqrs rT_squeeze_shape_rulers  1: >>rVct|tfdt|jjD}|jj |jjj |S)Nc30K|] \}}|vr|ywrYrirjrrrs rTrlz)_squeeze_sharding_rule..s$)Ax')rqr)rrrUrrr)rrrrs @rT_squeeze_sharding_rulersn _( )7+;+;+@+@!A))(       ' '8 ' < ! >>rVc|j|jj|jjjSr=r@)rArrs rT_squeeze_reduced_ruler@ 5::,,##++-- ..rVc.t|tt|k7rtd|tfdDstd|t fd|Drtdd|t fdt DS)Nzdimensions are not unique: c3PK|]}d|cxkxrtkncywrhrrjrzrqs rTrlz)_compute_squeeze_shape..s" 3QQ! c%j 3r|z$dimensions outside range [0, ndim): c3RK|]}tj|d  ywrxr~rs rTrlz)_compute_squeeze_shape..s%DAT " "58Q / /D$'zPcannot select an axis to squeeze out which has size not equal to one, got shape=z and dimensions=c32K|]\}}|vs |ywrYrirs rTrlz)_compute_squeeze_shape..sCTQ(1BqC )rrrrorrrU)rqrrs` @rTr r s _(]c*o% 2:,? @@ 3( 3 3 ;J<H IIDDD  8,  / 00 CYu-C CCrVcJtj|sJt||gSrY)r&rr)rrrs rT_squeeze_transpose_rulers&   (( ( a $ %%rVc|\}|\}tj||d}ttjd|}t |j |}tdt|}t|||fS)NrrNr) r'rmrrZr]r rqrDrr)rrrrrrbdim_outs rT_squeeze_batch_ruler"sl (' %$   gtQ /'RVVAz*+*' zB, q#l"3 4( Z 0( ::rVrc~~|j\}tj|||}tj|||gSrY)rr(rr)rrrrrs rT_squeeze_lowerr$s:mm)( S'8,#  + +Ch ? @@rVc vtj|d}t|dk(r!tdt j d|St j|rt j||S|Dcgc]+}ttt j||d-}}t|dScc}w)z?Converts a shape that may contain Poly values into a JAX value.Trrrrr.) rrrrzrZrris_constant_shaperrrrr%)rqrbrzrs rTshape_as_valuer's  ' 'd ;%Z1_ bhhq. // E" ::e5 ))  &t'>'>q'A5I $  TQ ''  s70B6ctd|Dsd}t|j|tjt j |}tj|}|ct|ttt j|k7r0d}t|j|t j |t|S)Nc3&K|] }|dk\ ywrhrirs rTrlz&_reshape_shape_rule..-s 'Q!V 'rmz/reshape new_sizes must all be positive, got {}.z_reshape dimensions must be a permutation of operand dimensions, got dimensions {} for shape {}.) rorpr}rrrZrqrrQrOr)rrrrrs operand_sizenew_sizes rT_reshape_shape_ruler,,s 'Y ' ' ;C CJJy) **288G,-, YYy !( :#eBGGG$4566/c cjjRXXg->? @@ y rVct|t|krdgfS||}}d}|ddk(r(|ddk(r |dz }|dd}|dd}|ddk(r |ddk(r dddgf\}}}} |t|kr0||||k(r| j||n|dz }|dkDrtj|d|d|||g} |dz} t j | ||k7s| t|kr|| dk(rt j | ||kDrdgfS|dz }|t|k\rdgfS| j||| dz } t j | ||k7rk| t|kr || dk(r| j| |dz }|dz }|t|kr0| j dg|zt|t| k(sJd| fS)NFrrrNz on more than 1 axis is not supported. Please specify the sharding of the output via the `sharding` argument of jax.lax.reshape. Got operand.shape=z and orig_new_sizes=T)rrrrcrrextend) rrr orig_op_shapeorig_new_sizesnum_1srjcountrtempnext_js rT_split_on_one_axisr6:s)^s8}$ "9"*I- & imq0 aKF}H#2I  imq0 1b[!Qs C N{il" jj! qje $$f33@/B   "# # l^d1uf YYt_ +s9~%)F*;q*@ 99T?Xa[ (  Q I   IaL!! YYt_ +s9~%)F*;q*@ jjFAFA1 C N2**aS6\ ] s3x '' ' srVczt|t|jk\rdgfSt||jdS)NFMerging)rrqr6)rrs rT_merge_on_one_axisr9es4^s7==)) "9 Iw}}i @@rVc||Std|jjDr |jS|jDcgc] }|dk7s | }}|Dcgc] }|dk7s | }}||k(r t ||St |j|d\}}|rt ||||St||\} } | rt|| ||Stjd|d|cc}wcc}w)Nc3$K|]}|du ywrYrirs rTrlz)_reshape_sharding_rule..ns2qd2rN SplittingThis reshape is not supported. Please specify the sharding of the output via the `out_sharding` argument of jax.lax.reshape. Got operand type: , new sizes: ) rorrrq(_split_merge_singleton_dim_sharding_ruler6_split_an_axis_sharding_ruler9_merge_an_axis_sharding_rulerrc) rrrrrnon_1s_op_shapenon_1s_new_shapeis_split out_splitis_merge operand_merges rT_reshape_sharding_rulerIks  O2G,,1122    ' 81aQ8/8!*5Aa1fa55(( 3GY GG*7==)[Q(I 'I(2 44/w B(M ' (2 44 y i[: ;;95s C C  C%%C%cVt|j|jjDcgc] \}}|dk7r|}}}t |}g}|D]5}|dk(r|j dt |}|j |7|jj|Scc}}w)NrNr)rrqrrr]rr^r)rrshsp filtered_specfsrrs rTr@r@s$' w7G7G7L7L$M&"bAg- M" ( aAvood 8boob     h //sB%cjt|tr|n|f}tjfd|DS)Nc3<K|]}j|ywrYry)rjrrbs rTrlz!_get_spec_size..s1Q4::a=1r)rrrr)rLrbtup_sps ` rT_get_spec_sizerRs*B&2RE& 1&1 11rVc.g}|jj}t||jjD]\}}t |t ry||j dgt|z7|;|dt||zdk(r&|j |gdgt|dz zzttjd|d||j|t|t|k(s J||f|jj|S)NrrNr>r?r) rrbrFrrrr.rrRrrcrr)rrFrrrrbrrLs rTrArAs (     $)W%5%5%:%:; gc2#t S)*  #a&>"d+C"Cq"HvSA667$$ %YmI; @A A oob  X#i. (?8Y*?? (    h //rVcg}|jj}t|jj}t ||D]\}}t |t r|D cgc] } t|} } td| Dr|jdR| dCtd| ddDr.|,|t| d|zdk(sJ|j| dtjd|d||jt|t|dJt|t|k(s J||f|jj|Scc} w)Nc3$K|]}|du ywrYrirs rTrlz/_merge_an_axis_sharding_rule..s #1Q$Y #r<rc3$K|]}|du ywrYrirs rTrlz/_merge_an_axis_sharding_rule..s%@Aa4i%@r<rNr>r?r)rrbr]rrrrr^rorrRrrcrr) rrHrrrrbop_specr+op_mergerrLs rTrBrBsf (     $ !!&& '' =9%h(D!#+ ,aDM ,b , # # # qE #%@AB%@"@  .A55:::1$$ %YmI; @A A ood7m$% gt  $$ $ X#i. (?8Y*?? (    h //! -sEcXtj|j|||\}}|g|fS)Nr)rrdr)rrrrrr,rs rT_reshape_typecheck_rulerZs9-- lliJ.(G W rVc|jSrYr)rrrrs rT_reshape_dtype_ruler\r rVc "tj|sJ|7t||jj|jj gS|jj j ttdtj|jj j|}tt|tj|jj||tj|gS)Nrc ||St|SrYr)rs rTrz)_reshape_transpose_rule..sAArVr)r&rrrrqrrrrrZrrrPrv)rrrrrt_ss rT_reshape_transpose_ruleras   (( ( Aw||)) 8M8M N OO ,,   & & c6''',,//44jAC D ' EC ga););Z!H+.0jj, . //rVc|\}|\}tj||d}|"dttjd|z}|tj ||d}t ||jdd|z||}|dfSrl)r'rmrrZr]rrrq) rrrrrrrrrs rT_reshape_batch_rulercs (' %$   gtQ /'bffQ 344J --i1EHr*Y6 % '# a-rVc|j\}|)tj|tj|}tj |||}tj |||gSrY)rr5rPr(rrr)rrSrrrrrs rT_reshape_lowerresXmm)( a--j9:A S!X&#  + +Ch ? @@rVcRt|||}|jt|f||S)Nrru)rrwr)rrvrSrrrrhs rT_reshape_staging_rulergs5 ) X N&  ( (QD&5@ ) BBrVrcyr%rirs rTrrr(rVc.tdd|tt|t|k7rd}t|j ||r?t ||j ks'd}t|j ||j |jS)Nrrz&rev dimensions must be unique, got {}.zYrev dimensions must all be less than operand ndim, got dimensions {} for operand ndim {}.)rXrrrpr}rrOrq)rrrss rT_rev_shape_rulerjsz5, 3ZS_, 2C CJJz* ++Z(7<<7 %C CJJz7<<8 99 rVc|jSrYrxrs rT_rev_sharding_rulerl s   rVcj|\}|\}|Dcgc]}||k\r|dzn|}}t|||fScc}wrIr)rrrrrrnew_dimensionss rT_rev_batch_rulerpsJ (' %$7AB!Q$YAEA-B.B Wn %t ++Cs0rct||gSrYrn)rrrs rTrrss1j/A.BrVc|j\}tj|tj|}tj |||gSrY)rr5reverser(rr)rrSrrrs rT _rev_lowerrts@mm)( At++J78#  + +Ch ? @@rVctt|tttjfs%d}t |j t|tt|ttjk7r'd}t |j |jtfd|DS)Nz;transpose permutation must be a tuple/list/ndarray, got {}.zitranspose permutation isn't a permutation of operand dimensions, got permutation {} for operand shape {}.c3<K|]}j|ywrYry)rjold_idxrs rTrlz(_transpose_shape_rule..,sA'w}}W%Ar) rrrrZrrpr}rrrQrOrq)rrrss` rT_transpose_shape_rulerx$s K%rzz!: ; GC CJJtK01 22 6+ 5w||)<#== 6C CJJ{GMM: ;; A[A AArVc|jj}|Dcgc]}|| }}|jj|j|Scc}w)Nrqr)rrr)rro_specrwrs rT_transpose_sharding_ruler{.sT    &-8 9'fWo 9( 9    fmmxm&H II:s Ac|j|jj|jjjSrrrArrs rT_transpose_unreduced_ruler~3s@ 5::,,  %%//-1 22rVc|j|jj|jjjSr=r@r}s rT_transpose_reduced_ruler7rrVcd|\}|\ftfd|Dz}d}t|||fS)Nc36K|]}|kr|n|dzywrxri)rjrrs rTrlz(_transpose_batch_rule..>s EAa$hAaC/Err)rrP)rrrrpermres_bdimrs @rT_transpose_batch_ruler;s? (' %$ 5EEE E$ ( 7D !8 ++rVc|j\}tj|jtjr]t j |jj}tt|Dcgc]}|j|z}}g||}tj|tj|}tj|||gScc}wrY)rrrrbr~rrrqrQrrOr5rPr(rr)rrSrr elt_shaper trailing_dimsrs rT_transpose_lowerrBsmm)( x~~v7**8>>:@@I05c)n0EF1X]]Q&FMF0K0-0K a--k:;#  + +Ch ? @@Gs<CrPcBt|tj|gSrY)rPrZrv)rrrs rTrrRs1bjj6M)N(OrVc tdk(r tdtfdddDrLd}t|jdj Dcgc]}t |j c}|j rP|j dj k7r4d}t|j|j dj dj Scc}w)Nrz"select must have at least one casec3VK|] }|jdjk7"ywrhry)rjcasers rTrlz%_select_shape_rule..Zs"<$uQx~~ %<&)rNz1select cases must have the same shapes, got [{}].rzfselect `which` must be scalar or have the same shape as cases, got `which` shape {} but case shape {}.)rrprr}rrrq)rrrsrs ` rT_select_shape_rulerWsZ1_ 8 99<%)<< =C CJJtyy)F1#agg,)FGH II [[U[[E!HNN2 5C CJJu{{E!HNN; << q *GsC)c |Dcgc]/}|jjjr$|j1c}stjSt fdddDrVd}tj |jdj|Dcgc]}t|jc}|jre|jjjsE|jdk7r3tj d|jd|djddScc}wcc}w) Nc3.K|] }|dk7ywrhrirs rTrlz(_select_sharding_rule..g6k!n 6r_rNz4select cases must have the same shardings, got [{}].rrzWselect `which` must be scalar or have the same sharding as cases, got `which` sharding z but case sharding rn) rrbrrrrrcr}rrrq)rrrrsrs @rT_select_sharding_rulercs %*H!**//2G2GH+   % % ''6k!"o66 @C   499u=!c!**o=>? AA kk%..--33 nn A&   "^^,- !H   a ! "" QI >s%D6D6D;ctdg|tj|jtj sGtj|jtj std|jdtj|jtj rt|dkDr td|djS)Nrz4select `which` must be boolean or integer type, got rnrMz2select with boolean `which` cannot have > 2 cases.r) rVrrrbrZr0r1rprrs rT_select_dtype_rulertsH%u%   EKK 2   EKK 4 J{{m1& '' u{{BHH-#e*q. H II qrVc&td|DS)Nc34K|]}|jywrYrrs rTrlz)_select_weak_type_rule..s (QQ[[ (r1)rors rT_select_weak_type_ruler~s (% ( ((rVctj|rJt|tjurHdg|Dcgc]8}tj|rtj|j nd:c}zSt |d}tj|tjtjk(rStj|dr t|||nd}tj|dr t|||nd}d||fSdgt|Dcgc]=\}}tj|r!tt|t||||nd?c}}zScc}wcc}}wr5)r&rrr rrrrrbrZr0rrUrzr) rrrrrct0ct1rrs rT_select_transpose_rulersH  # #E ** * !W  6#%.0-C-CA-FW\\!&&)DP% %% aOE ||Ebhhrxx00')'='=eAh'GF5% #Tc')'='=eAh'GF5!U #TcC VCLUCS8?4R # #D ) E6%+,a 7/3 4%s =E+#AE0c  |^} |^ tdt||D}t fd Drtj|tj dk(rt |g  fStj |dk(sJt| dj gtj dj}t |g  fStj |dk(rtd Drt fd ddDrt |g  dfSt fd DrP d}t dd ddDcgc]\}}tj|||} }}t | dg| |fStj|r"tj| ||jn|}td Ds?t Dcgc]'\}}tj||||j)c}} t fd  ddDsJdtj |cxkrtj dkrZnnWtj |dk(sJt| djdgtj dj}tj |tj dkDrAtj ddk(sJ Dcgc]}t||jc} t |g dfScc}}wcc}}wcc}w) Nc3DK|]\}}||j|ywrYryrs rTrlz%_select_batch_rule..rrc3(K|] }|k( ywrYri)rjr which_bdims rTrlz%_select_batch_rule..s3t 3r0rrNrc3$K|]}|du ywrYri)rjrs rTrlz%_select_batch_rule..s"K4t#3"Kr<c3.K|] }d|k(ywrhri)rjr case_bdimss rTrlz%_select_batch_rule..s .s+ >1RXXeAh 288A; . >8;c3LK|]}dtj|k(ywriNrrs rTrlz%_select_batch_rule..s .1R288A;  .s"$c3zK|]2}tjdtj|k(4ywrhrrs rTrlz%_select_batch_rule..s+ B1RXXeAh 288A; . Br)r^rrorZrqrrOrrrrr'rmrexplicit_mesh_axisr) rrr unused_kwargsrrrrc_bdim other_casesrrrs @@@rT_select_batch_rulers-%%&*z  Sz%B  $ 3 33 xx"((58,, e $e $j 00WWU^q  ueAhnnzl,0KKa,A,J,JLe e $e $j 00 wwu~s"K "KK  > > ]d&)%)Z^&DF"F&&q&$7FkF eU1X 4 4d ::hhuo  ! !%T"+">"> @#( . . .z2 4D # #AtT93O3O P 4E Bab B BB B+"''%(++ 775>Q   UE!HNNQC*.++eAh*?*H*H JEWWU^bggeAh'' 7758  !! !05 61Yq%++ & 6E % % ! ##'F 4 7s!M-,MM cT|^}}|dd}t|g|}td|Dr&tj|dj}||fSt t d|D}|Dcgc]!}t|tjur|n|#}}t|g|}||fScc}w)NrNc3RK|]}t|tju!ywrYrrs rTrlz_select_jvp..s8QaGLL 8rrc3XK|]"}t|tjus|$ywrYrrs rTrlz_select_jvp..sL!Qw||0KALs **)rror rrrr^r) rFrGr case_primals case_tangentsrout_dotzrs rT _select_jvprs %,12,-&&#8-88ll=+001G g tL}LLMABOPQ$q'W\\1Qq8PMPu-}-G gQs-&B%c< |j}|j\ t fd|ddDsJt fd|ddDsJt}t j }|gt |dz z}|d}|j|j}|jd|j|jk(sJtt|j} tj|||| } tj||| g||g||gddS)Nc3K|]5}|j|jfjjfk(7ywrYrrj aval_casers rTrlz._select_hlo_lowering_opaque..s8 ,ooy /HNNHNN3S S ,s;>rNc3K|]I}|jjjs'jjjs|k(KywrY)rrbrrs rTrlz._select_hlo_lowering_opaque..sI Q )    $ $ * *83D3D3I3I3O3O8 QsAArrrr)rrro_select_hlo_loweringrrrrrbrqrOrrQr(rr) rrrr select_lowerphysical_aval_outphysical_avals_cases aval_whichaval_which_bcast bcast_dims which_bcastrs @rT_select_hlo_lowering_opaquersQ \\(mm)(  ,&qrl , ,, ,  Q-5ab\ Q QQ Q&,((2+,H 0AB{*&--J4D4D-E    0 1Z5E5E EE EE*//*+*%% 5"E+    < %', % 8#78"# %&' ((rVcjdj\}tj|jtj r%t g|}tj||gSjtjtjk(rUt|dksJt|dk(r|Stj|d|d}tj||gStjjtjrdnddfdd|}tj||gS)NrrMrNrrrc "t|dkDsJt|dk(r|dSt|dz}tjtj||z }t j |||d|||z||dS)NrrNrM)rr(rrr5r) rrmidr_selectrrrr which_avals rTrz%_select_hlo_lowering.._selects u:>> 5zQ 1Xo e*/C   E //Vc\:N  .D ::dGFE$3K8fslE#$K8 ::rV)rrrrrbr~rr(rrZr0rr5rr) rrrrr$rrrrs `` @@@@rTrrs#||A*mm)( x~~v7 $S% 8% 8B  - -c2x @ AA"((++ u:?? 5zQu E58U1X .B  - -c2x @ AA z'')9)9:LL " : :q%"  + +CX > ??rVrcyr%rirs rTrr r(rVc .t|t|dzg\}}td|Dr'|Dcgc]}|j}}t d||Dcgc]+}t t j|j|-c}Scc}wcc}w)NrMc3:K|]}|jdk7ywrry)rjrs rTrlz%_reduce_shape_rule..s3Sb3sz'reduce found non-scalar initial value: )rGrrrqrrrZrh) r rrr operand_avalsinit_val_avalsrinit_val_shapesr$s rT_reduce_shape_rulers",USZ1_4E"F-3N33(671qww7O7 >>OP QQ;H IR% "((J/ 0 II8 Is B 0Bc t|t|dzg\}}|Dcgc]<}|jjt |jj |>c}Scc}w)NrMr)rGrrrr1r)r rrrrrr$s rT_reduce_sharding_rulersaE a'89-! # ++  ,r{{/?/?"L  M ## #sAA%ct|t|dzg\}}tjdg|}|gt|zS)NrMr)rGrrrq)r rrrrrrs rT_reduce_vma_rulersEE a'89-  " "8 :J L MM  6;s A'A,ct|t|dzg\}}t||Dcgc]\}}|jxr |j!c}}Scc}}wr)rGrrFr)r rrrrrr$init_vals rT_reduce_weak_type_ruler*s_",USZ1_4E"F-&}nE Gb( ,, -8-- - GG Gs$Ac t|dz}t||g\}}t||g\}} td| Drtdt ||D} t ||D cgc]\} } t j | | | }} } |D cgc]} | dz }} dg|z}tj||z|t||d|fStcc} } wcc} w)NrMc3@K|]}|tjuywrY)r' not_mapped)rjinit_value_bdims rTrlz%_reduce_batch_rule..5s# 2  H// / 2sc3DK|]\}}||j|ywrYry)rjrSr=s rTrlz%_reduce_batch_rule..7s(#2> #rrNr)r rr) rrGror^rr'rrrrr)rrr rr num_operandsr#r operand_bdimsinit_value_bdimsrrrrzronew_operand_bdimss rT_reduce_batch_ruler/s \"a',$\L>B(K$.zL>$J!-! 2 0 22 #\:)F# #D"%X}!=?C&&sD$7?H?%/0a!e0N0l* ==8k1%0$).$9$ &(9 99 ?0s ,!C Cc> tj|djttjt |}tj tjt| |t z |ft z t fd|D}t fd|D}tt dzD]}tjdd fd }tj|||S)Nrrc38K|]}t|ywrYr)rjrSrrs rTrlz_reduce_jvp..MsF'!Y 4Fc38K|]}t|ywrYr)rjrrrs rTrlz_reduce_jvp..NsH!71i5HrrNroc |djdkDr|dj}|dzdz}||z }|Dcgc]}tj|d|}}|Dcgc]}tj||d}}||k7rJdgt|djz}d|<t | D cgc]\} } t | | |}} } ||z}|djdkDr|djdk(r D cgc]} t | c} Stfd|DScc}wcc}wcc} } wcc} w)z9Reduce by repeatedly splitting the array and multiplying.rrNrMNr)rrNrc38K|]}t|fywrY)r)rjrSr)s rTrlz4_reduce_jvp.._reduce_tree..as1TG$1r)rqr+ slice_in_dimrrrrzr)r)r>rn1n2rSxs1xs2paddingsrrr input_shapenon_axesreducers` rT _reduce_treez!_reduce_jvp.._reduce_treeRsR Q%++d a  Q%++d a Ea.js;a $;rzeGradient of general lax.reduce with non-zero tangents for initial values to reduction not implemented)rGrrrrrr) rFrGr rr primal_xsr tangent_xs tangent_initrs rT_reduce_jvp_ruler es%gG 0A/BC)['3x=A3E2FG*l ;l;; 4 55   e $' Wk9j* MMrVrc td|jDsJ|jtj|t |dzg\}}|jt |dzd}t j |jDcgc]}tj|c}||tj|} |Dcgc]}tj|} }| jdjj| | z} tj| 5t!j"} |j$r t'dtj(|j*|j,| tj.|j0g| j2|j4|j6d\} }t j8tj:| dddt=| j>|jDcgc]\}}tj@|||c}}Scc}wcc}w#1swY[xYwcc}}w)Nc3PK|]}t|tj ywrYrrr!rs rTrlz _reduce_lower..} CZ4++ , CrrMrz Cannot lower effectful `reduce`.)dim_var_valuesr)!rorrrGrr5ReduceOprr(rrregionsblocksrr3InsertionPointrnew_name_stackrr jaxpr_subcomprrTokenSetr argumentsr rreturn_rrFrr)rr rrrr#rinit_value_avalsrr$ir_typesr name_stack out_nodesrr<s rT _reduce_lowerr {s Ccll C CQS\\Q C//&3v;!3C2DE(K\\#f+"2"34 ||CMMJDT))$/Jk4+?+? +KM"5E FTd""4( F( F 'BJJqM ' '(X*= ?' ! 3!002J }}  B CC%%c&8&8%++&0$--/&+llI(/'8'8I695G5G585G5G ILIq KK&&y12 3""**cmm< >a  + +CD 9 >>K F 3 3 >s H8 H=%CI!II ctj|jtjs.t dj |t|j|jS)NzD{} does not accept dtype {}. Accepted dtypes are subtypes of number.)rrrbrZnumberrpr}r0)rrrrs rT_reduce_number_dtype_ruler sM   7==")) 4 !!'ogmm.L!M OO rVc \tj|sJ|jj}t t j t jt||}t||||jjj}|j|k(sJ|gS)Nr) r&rrrqrrZrhrrrr{r)rjrrrrrr s rT_reduce_sum_transpose_ruler s   (( ( ""+ryy3{3C)DdKL 2<<113<< >&  $$ $ /rVc ~|\}t|jD cgc]-\}} t| tjr|| j f/} }} t |||j| } || |gScc} }wrY)rUrqrrBoundedAxisSizera_replace_masked_valuesrb) traceableidentrrrrrrrrz padded_axesoperand_s rT_reducer_paddingr! sy %$(1$**(=71q""4"45QUU7+7 #GU4::-> L( Hd # $$7s2A:c |s|Stjt}|Dcgc]\}}t||j||k!}}}t t tj||t||Scc}}wrY) rscalar_type_to_dtyperrrqrrrrr)rSrar rbrrzmaskss rTr r sj Qh  % %c *%?J Ktq! E177A . 2 K% K  u-q)As2C DD Ls$A9)rc ~tttk7rtdtfdDstdddt t fdt jDS)Nz(duplicate value in 'axes' of reduction: c3RK|]}d|cxkxrjknc ywrhr)rjrrs rTrlz(_reduce_op_shape_rule..s" 1qQ! "gll " " 1rzreduction axes z$ contains out-of-bounds indices for rnc32K|]\}}|vs |ywrYri)rjrrzrs rTrlz(_reduce_op_shape_rule..sGTQ$qGr)rrrrorrrUrq)rrrrs`` rT_reduce_op_shape_ruler( s|Y#c$i. ?vF GG 1D 1 1 tf,PQXPYYZ[ \\ 4$ GYw}}5G GGrVc|t|tsJ|Sttt fdt |j jD}|j j|S)Nc30K|] \}}|vr|ywrYrirjrrrs rTrlz,_reduce_sum_sharding_rule..#(DAq$(rr) rr8rrrrUrrr)rrrrs ` rT_reduce_sum_sharding_ruler- sp lM 22 2  4$ (Ig.>.>.C.C$D(()(    h //rVc |jjjrtjd||jjx}rnt t fdt |jjDtfd|Dstjd|dd||S)Nz>operand passed to reduce_sum cannot be unreduced. Got operand=c3fK|](\}}|vs t|tr|n|fD]}|*ywrY)rr)rjrrrrs rTrlz-_reduce_sum_unreduced_rule..sGAaQ$Y$T51$wA  A As 1!1c3&K|]}|v ywrYri)rjurjs rTrlz-_reduce_sum_unreduced_rule..s9QqL 9sz^out_sharding's unreduced axes should be in operand's specs that were summed over. Got operand=z, axes=z, unreduced_spec=)rrrRrrcrrUro)rArrrunreduced_specrjs ` @rT_reduce_sum_unreduced_ruler3 s $$  I K MMzz+++^+ T?DA"7#3#3#8#89AAL 9.9 9  " " -$+:Xw7+, . // ,rVc |j|jj|jjjSr=r@)rArrrs rT_reduce_sum_reduced_ruler5 rrVrc\d}t|t|ddg|||\}}|d|dfS)Nct||gSrYrr#s rTrz'_reduce_prod_jvp_rule..s#a)rVrrN)rr)rFrGrr primals_out tangents_outs rT_reduce_prod_jvp_ruler: sC $')'F71:q4I3J*18TC+| Qa ((rVctttfdt|jj D}|jj |S)Nc30K|] \}}|vr|ywrYrir+ s rTrlz+_reduce_op_sharding_rule..r, rr)rrrrUrrr)rrrs ` rT_reduce_op_sharding_ruler= sT 4$ (Ig.>.>.C.C$D(()(    h //rVr3c t|jDcgc] \}}||vrdn|}}}tt|t |||j }t ||}tt t||||Scc}}wrI) rUrqr_eq_meetrrbrrgrd) rrrrrrzrqlocation_indicatorscountss rT_reduce_chooser_jvp_rulerB s.7w}}-E FTQT 1q F% F,wU+,agg7 )4 0& ZA23T :F CC GsBr:r<c|\}d|cxkrt|jksntd|d|j|j|dkrtd|jd|tj|j|S)Nrz Invalid axis rrNzEargmin and argmax require non-empty reduced dimension. operand.shape=z axis=)rrqrrr1rrrr)s rT_argminmax_shape_rulerE s %$ t (c'--( ( }TF*=gmm_M NN ]]41 &&-mm_GdW> ??  7==$ //rVc|\}|jjtj|jj|SNr)rrrr1rrD s rT_argminmax_sharding_rulerH sC %$     ((--t4 ! 66rVctj|tjs#t dj t ||S)Nz/index_dtype must be an integer type, but got {})rrrZr1rpr}r0)rrrs rT_argminmax_dtype_rulerJ s;   ; 3 EVOK89 ;; rVc eZdZddZdZdZy)_ArgMinMaxReducerc||_yrY)_value_comparator)rvalue_comparators rTrz_ArgMinMaxReducer.__init__&s -DrVc6d|jjdS)Nz_ArgMinMaxReducer(r/)rN rr7s rTr8z_ArgMinMaxReducer.__repr__)s   6 6 ? ?@ BBrVc |\}}|\}}t|j||t||}t|tt ||t ||}t |||t |||fSrY)rQrN r~rMrzrr) r op_val_index acc_val_indexop_valop_indexacc_val acc_index pick_op_val pick_op_indexs rT__call__z_ArgMinMaxReducer.__call__/s#FH&GYT33FGD/1K{*2fg+>+-h +B DEM ; 0 =(I 6 88rVN)rO Callable[[Any, Any], Any])rrrrr8rZ rirVrTrL rL $s.C 8rVrL c|\}t|tj|||jj}t ||g||j tjd|gt||}|dS)NrrrN) rrZrqrrrrbrrL )rO get_identityrrrr)rrs rT_compute_argminmaxr^ <sx %$ 288G$d<<(( *' !W]]+RXXa-EF !12 # Q-rVrr )inlinec|jtjk7rGtj|jtjst d|jdt tj|j|S)Nz:logical reduction requires operand dtype bool or int, got rn) rbrZr0rr1rprrhrqrVs rT_reduce_logical_shape_rulera js_ ]]bhhr}}W]]BJJ'O PQXQ^Q^P__`a bb ryy- ..rVcv|jjt|jj|SrG )rrr1rrVs rT_reduce_logical_sharding_rulerc os/    l73C3C3H3H$&O PPrVc|\}tj||}tj|j |ddfdfS)NrTFric.tjSrY)r r)rrrs rTrz _reduce_or_lin..vsGLL$6rV)r]rrrto_tangent_aval)rrSrrr$rs @rT_reduce_or_linrg rsE #"qt$! Q ' ' )$ E26 66rVr5r7r8c |j\}|j}tjt j |g|gt j ||jgt j|}t j tjd|} |jdjj| | } tj| 5tj|| j gdddt j"||j$|gS#1swY+xYw)Nrir)rrbr5r r(rrrrr!r r rr3r r r rr ) r unit_factoryrrSrrrrbr$ scalar_typereducer_regions rTrrsmm)( ..% ||T))(34qc%%l8>>&BCD((.0"$$T%5%5b%%@A+::a=''..{KH. (6KK.223456  + +CH E FF66s &$D44D=ctj|}tj|}|dkrtd||dkrtd||jS)NrNz6reduce_precision: exponent_bits must be positive; got rz:reduce_precision: mantissa_bits must be non-negative; got )rrrrqrs rT_reduce_precision_shape_rulerm s`../-../-Q Mm_] ^^Q QR_Q`a bb rVc|jSrYrxrs rT_reduce_precision_sharding_rulero rrVr)rrFrGc 0tj|fi|gSrY)rr)rrs rTrrs6H6M6Ma6ZSY6Z5[rVc|j\}tj|tj|tj|}tj |||gSrY)rr5rr(r r)rrrrrrs rT_reduce_precision_lowerrr sNmm)( WdmmM&B!]]=9 ;#  + +Ch ? @@rV) @cttfdddDr&djdD}td|Dcgc]N}|jj j s,|jj jr |jPc}tfdddDr0djdD}tjd|Scc}w) Nc3VK|] }|jdjk7"ywrhry)rjrrs rTrlz&_sort_abstract_eval..s":eAhnn $:rrN c3FK|]}t|jywrYrrjrs rTrlz&_sort_abstract_eval..s2qc!''l2rz/Arguments to sort must have equal shapes, got: c3.K|] }|dk7ywrhrirs rTrlz&_sort_abstract_eval..rr_c32K|]}t|ywrYr_rs rTrlz&_sort_abstract_eval..s5AQ5sz2Arguments to sort must have equal shardings, got: ) rrrrprrbr_any_axis_explicitrrc)rrrur shardingsrs` @rT_sort_abstract_evalr s ,%:ab :: XX2E2 2F EfXN OOK ZZ__ " "qzz'I'IjjK+ 6k!"o66555I  t t j ||ttj |||nt j ||}v|SNrfr) _operands_to_keysrrrrQlt_to_prrMeq_to_prfr#x_keysy_keysrxkyks rT_sort_lt_comparatorr $hBB.&& !F4R4L&2,/$fb"  ' 'B /FBSTS`GLLR(+gll2r6JA*N Oll2r"$ (rVc Dt|d|i\}}d}t|ddd|dddD]t\}}tj||\}}|>t t j ||ttj |||ntj ||}v|Sr ) r rrrrQr rrMr le_to_pr s rT_sort_le_comparatorr r rVc t|dk\rt|dzdk(sJ|t|dz|k\s J||fgg}}t|dd|zd|dd|zdD]_\}}|j|jk(sJ|j|jftj|jt j ro|jtt|tt|g|jtt|tt|gtj|jt jr6|jt||jt|>|j||j|b||fS)NrMrrN) rrrbrrrZrr.r r(r,r r)rfr#r r rSr$s rTr r s} X! H  1Q 6@@ 6 X! x '=(H)== 'r&&(=AhJq=)8AajN+CD da 77agg 111  ""4"45 mm1$q':# NND3u:.<s#!Gq! QF!Gs  rrj)r^rrZrhrrOrrrqrrrr'rmrrkr) rrr!rerf prototype_argnew_bdimnew_argsrrr new_dimensionrs rT_sort_batch_ruler ;s !G<4!GG- (|Z0>ic4 | YYryy!3!34h ?doo& }""D{{=1::<=ooh''T8<=>x945- +H %% ++x=IX` a  rVrgc td|jDsJ|jtj|jDcgc]}t j |c}t j|t j|tjj|}d}|jDcgc]}|jd||}}tt j |} |jjj t#j$t'| | } tj(| 5t j*t-t.d} |j1dt#j$t'||t3j4dt6j8g} | | g| j:d |i} tj<t j| ddd|j>Scc}wcc}w#1swY|j>SxYw) Nc3PK|]}t|tj ywrYr rs rTrlz_sort_lower..Vr r)r!recJ|jjtSrG )rrrrs rTrz_sort_lower..[sqzz((ac(2rVrirFr) primitiverrrf) rorr5SortOprr(rrrr3BoolAttrrrrE comparatorr rrflattenrr rrr rrr!rZr0r r r)rr!rerfr#rrgscalar_s scalar_avals scalar_typesr lower_comparatorsub_ctxrs rT _sort_lowerr Us Ccll C CQS\\Q C CMMJDT))$/J**84"mmI6 kkooi8 :$3(!ll,++B$+@,,,$.. =,,t%%,, ||C l346* $-~~g.A&B7<>kkD#'<<L,0O#P%)%5%5b"((%C$DFG 7 MZ%9%9 MH MCKK&&s+,- 'K , - s H" H'B7H,,Icntj|jtjr t d|dkrt d|t |jdk(r$tdj|jd|cxkrt |jksnt d|d|jt|j}|||krt d|d|d |tjd j} |||d zkD}|rt d |d |j|||<|j||j|j |j|tjtj"fS#tj$rYvwxYw)Nz,top_k is not compatible with complex inputs.rrqz.top_k operand must have >= 1 dimension, got {}z!axis argument out of range: axis=z for operand.shape=zBk argument to top_k must be no larger than size along axis; got k=z with shape=z and axis=rrNzetop_k returns int32 indices, which will overflow for array dimensions larger than the maximum int32 (z). Got operand.shape=rqrbrr)rrrbrZrrrrqrpr}rr[r`rInconclusiveDimensionOperationrrr)rrr)rq int32_max too_larges rT_top_k_abstract_evalr os w}}b&8&89 C DDU DQCH II1 DVGMM* ,, t (c'--( ( 9D7:N ?OP QQ w}} % 4[1_  D uhkD7< ==ll7#'')]ty1},I 99B CY7==JZ\ ]]%+ ..uGMM#*#4#4  6 ..uBHHRXX,>. ? AA  , ,  s FF43F4c 0|\}|\}t||}t|tjur#tjj |d}n|\}} | j } t | } | dz} t| | } d| z}tjdftfdt| Dtfdt| Df}tj|| ||}||tjj |dffS) Nrorrric3.K|] }|k7s |ywrYrirjrr)s rTrlz_top_k_jvp..s#H!a4iA#H c3.K|] }|k7s |ywrYrir s rTrlz_top_k_jvp..s)NAI!)Nr )r r r r r rN) rurr rrDrqrrr+r rrQr )rFrGrr)rrr8 r rk_idxs idx_shapergather_index_shapegather_indicesr r s ` rT _top_k_jvpr s (' ('gqt,+ ']gll",,00Q@KIAv I y>D"T)V%78N+K  * *"W##HuT{#HH$))NU4[)N$N  E...%MK {GLL$B$B;q>$RS SSrVcJ|\}|\}||kr|dz }t|||||ffS)NrNrr)ru)rrrr)rrs rT_top_k_batch_ruler s8 (' %$ T\AID w!$ '$ 55rVruc t|jdj}||dz k7rOtt |}|d||c||<|d<t j |tj|}nd}tj|r4tj|tj|j}nttj||f\}|j \}} tj"dtj$|tj$| g||gj}|6|D cgc]+} t j | tj|-}} |Scc} w)NrrNrzstablehlo.dynamic_top_k) result_typesr#)rrrqrrQr5rPr(rrrsr4TopKOprreval_dynamic_shape_as_valsr custom_callr) rrrr)rOrrk_valueout_values_avalout_indices_avalr s rT _top_k_lowerr sP S\\!_ " " #$ TAX d D8T$ZDJRmmGT%9%9$%?@G D !kk'4==#34<.s3Q. 3sz%Arguments to after_all must be tokens)rrpr"r s rT_after_all_abstract_evalr s"3(33 ; << rVr cJ|j\}tj|gSrY)rr5r r s rT_after_all_loweringr smm)( -- ! ""rVcvtj||\}}tj||t |S)aStateful PRNG generator. Experimental and its use is discouraged. Returns uniformly distributed random numbers in the range [a, b). If b <= a, then the result is undefined, and different implementations may return different results. You should use jax.random for most purposes; this function exists only for niche use cases with special performance requirements. This API may be removed at any time. ry)rr rng_uniform_prrrr}rqs rT rng_uniformr  s6  # #Aq )$!Q   Aqe  55rVc|j|jk7r/tdj|j|j|jdk7s|jdk7r/tdj|j|j|j ||j|j xr |j S)NzCArguments to rng_uniform must have identical dtypes, got {} and {}.riz?Arguments to rng_uniform must be scalars; got shapes {} and {}.r )rbrr}rqrrr s rT_rng_uniform_abstract_evalr  sWW qww( **WW]aggm G vaggqww !! QWW[[8Q[[  ;;rVr c |j\}tjtj|j tj }tj|||tjjdgS)NUNIFORM) rr(rrZrrqrr5rngRngDistributionAttrr)rrr}rqrs rT_rng_uniform_loweringr $ sYmm)(   288HNNBHH= >% ''!Qs66::9E F GGrVc4~~|jt|fSrY)rqrrrqrbrrs rT_rng_bit_generator_shape_ruler , s Y ))U5\ ""rVc|j|fSrYrxr s rT _rng_bit_generator_sharding_ruler 0 s ,, %%rVc.|jtfSrY)rrr s rT_rng_bit_generator_vma_ruler 4 s ''9; rVc"~~|j|fSrYrr s rT_rng_bit_generator_dtype_ruler 7 s Y ))U rVc$~~~|jdfSr'rr s rT!_rng_bit_generator_weak_type_ruler ; s UI -- rVc eZdZdZdZ dZ dZy)RandomAlgorithmz.y s"DT # #AGG , ,Ds*,z#stablehlo.dynamic_rng_bit_generator) rng_algorithm)r r#extra_attributes)r3RankedTensorTyperrq element_type IntegerType get_unsignedrZrbr(rUrr5rrrr rrreval_dynamic_shaper rrr!rrRngBitGeneratorOpr)r)rrrqrbrrkey_type key_shape key_etypeu32_typeu64_typeetype rbg_etype rbg_dtypealgorithm_attr out_key_aval out_vals_aval output_shapeout_keyout_valss rT_rng_bit_generator_loweringr& Z s   *(!)>)>Y)^^ ( ( ,( ^^ ( ( ,(   X 5   X 5P:CY9OP 7 ((5/%    &% rxx "((8"4bhhx6Hxx!##III I(   X. B''++QFH=sC EC"),. # , DcmmDD$$ c=#6#679L((-hh**4+;+;E9+MNP|$N; = >EW GX--  y1%WGX(kk X.     # #QFH 5w @AG%{{b11(--@FFNH  + +C, G  + +C= I KKrVrng_bit_generatorc,tj|SrYcopy_pr)arrs rT _array_copyr, s S rVcd}t|jjD]4\}}t|tj tj fs1|}|S|SrY)rU sharding_specrrr* UnstackedChunked)r sharded_dimrs rT_which_dim_shardedr2 sV+001 da!dnndll34k    rVc|SrYrirRs rT _identity_fnr4 sAXrVctjtddd||\}}}tjt||||ddd|| }t j |j g|jd||j|j|j|j|j|j j|j|jd }t!j"|j%|S)Nri) backend axis_name axis_sizeglobal_axis_sizedevicesr8out_axes_thunkrdonated_invarsis_explicit_global_axis_size)r_shared_code_pmapr4 _prepare_pmapr* xla_pmap_implrrlocal_axis_sizer9 r: in_axes_flatr; rr< r= rrr)r1 rrr7 static_broadcasted_tuple donate_tuplerrs rT_copy_impl_pmap_shardingrE s696K6K$B [7:3) %| K.FD$dF4!  jj;;(, !!A4F4Fii%%AJJ,?,?%%#$#A#A (  ! !!**, 99rVc|\}t|trYt|jtr?t |j}|t j |g|i|St|g|i|St j |g|i|SrY)rr<rr7r2 rapply_primitiverE )rLrrrr1 s rT _copy_implrH s "!5j\B$QZZ0K  % %d . !s 7QV  ua ( 7rzBiota does not accept dtype {}. Accepted dtypes are subtypes of {}.c34K|]}|jywrYr0rs rTrlz&_iota_abstract_eval.. !s3!**3r1rrz?iota dimension must be between 0 and len(shape), got dimension=z for shape=rrx) rXr_numr0rpr}rrrrrrr!)rbrqr!rrsr9r:s` rT_iota_abstract_evalr_ !s67E* 7$ 7 7 NCu%H3d3 CJJx3E)FG HH i $#e* $ #!|<2 33 ))tvvvE 7J/KLH UEH 55rVrcRt||||}|jtd||S)Nrriru)rrwr)rrvrbrqr!rrhs rT_iota_staging_rulera !s8 e5I! #&  ( (V7B ) DDrVcDtj||||\}}|g|fS)Nr)rrd)rrbrqr!rr,rs rT_iota_typecheck_rulerc !!s3** )h+H(G W rVc~|j\}tj|||}tj|||gS)Nr.)rr(rr)rrbrqr!rrrs rT _iota_lowerre '!s: mm)( #x95#  + +Ch ? @@rVc tjtj|dsd}t|j |dt |t |z zt |z}t ttj||S)zCUtility function for computing the shape resulting from a dilation.rz'All dilations must be positive, got {}.r) rZrogreaterrpr}rrrrr)rqdilationrss rT _dilate_shaperi 3!sj  8Q' ( 3C CJJx( )) SZ#h-/ 05? B( s4??E84 55rVcVtjtj|| SrY)rZ floor_dividerrs rT _ceil_dividerl ;!s //"++b/2 . ..rVceZdZdZdZdZy) PaddingTyperNrMrxN)rrrVALIDSAME SAME_LOWERrirVrTrn rn ?!s % $*rVrn c2t|trDtjtjtj d} ||j }|tjk(s|tj k(rt||}d|dz |z|z|z D}|tjk(r|D cgc]} | dz| | dzz f} } n|D cgc]} | | dzz | dzf} } | D cgc].} t| tjr| jn| 0c} S|tjk(rdgt|zSd}t|j|#t$r"}d}t|j||d}~wwxYwcc} wcc} wcc} w) z6Convert padding string to list of pairs of pad values.)ro rp rq z>Unrecognized padding type: expected 'VALID' or 'SAME', got {}.Nc3HK|]}tj|dywrh)rr]rs rTrlz"padtype_to_pads..V!s#3a#3s "rNrM)rrzUnknown padding type: {}.)rrrn ro rp rq upperKeyError RuntimeErrorr}rl rZritemrrp) in_shape window_shapewindow_stridesrmappingrrsr pad_sizespad_sizepadsrs rTpadtype_to_padsr E!s""  !,,G 7 (g     G{/E/E$EX~6I3$q=N:&')123I+"""DM8@8q=(X]2 3d EN8@8h!m #X] 3dCG GQ 1bjj1AFFHq 8 GG+### 8c(m ## %C CJJw' ((/ 7 Lc G, -367 Hs*E3F F(3F F%FFfabsarccosarccosharcsinarcsinharctanarctan2arctanhrMrJrQrTr;r2rg rr less_equal logical_and logical_not logical_or logical_xormaximumminimumr not_equalr float_powerr left_shift right_shiftsubtractc 0td|Dryt|dkry|djtfd|ddDrMd}|tvrt|}|d|d z }t |j |d j d |Dy) z;Check that dtypes agree, possibly ignoring float precision.c3xK|]2}tj|jtj4ywrY)rrrbr~)rjrs rTrlz$check_same_dtypes..!s%JD  4::v 7Js8:NrMrc3<K|]}|jk7ywrYr)rjrrbs rTrlz$check_same_dtypes..!s3u 3rrNz:lax.{} requires arguments to have the same dtypes, got {}.z (Tip: jnp.zE is a similar function that does automatic type promotion on inputs).rc3FK|]}t|jywrY)rrbrz s rTrlz$check_same_dtypes..!s.Ks177|.Kr)rrrb_JNP_FUNCTION_EQUIVALENTSrpr}r)rrrsequivrbs @rTrVrV!s JEJJ Z!^ (..%3qr33 FC (('-e {5'!f ggc CJJtTYY.KU.K%KL MM 4rVc ht|tttjfs'd}t |j ||t|t|sytj|}|jdk7r&d}t |j |j t||rdnd\}tfd|Dsd }t |j ||||y#t $r;}d}t |j ||ttt||d}~wwxYw) zHCheck that `obj` is a shape-like value (e.g. tuple of nonnegative ints).z1{} {} must be of type tuple/list/ndarray, got {}.NrNz${} {} must be 1-dimensional, got {}.z9{} {} must have every element be an integer type, got {}.)rNzstrictly positive)r nonnegativec3(K|] }|k\ ywrYri)rjrz lower_bounds rTrlz#_check_shapelike..!s /!Q+  /r0z,{} {} must have every element be {}, got {}.)rrrrZrrpr}rrrrOr#rro) fun_namerobjnon_zero_shapersobj_arrr bound_errorr s @rTrXrX!s  C%rzz2 3 =C CJJx49= >> S HHSM' \\Q 0C CJJw||, --Tw #16H+{ /w / / 8C CJJx;D EE 0 T EC CJJx5T33HI JPSSTs% C-- D166D,,D1ct|}tj|rAtj||}|t|k(r|St j ||St jt j ||dS)NFr)r1ris_python_scalarscalar_type_ofrZrrr)examplerarbs rTrr!so /% W% (&   ( -C6#;&3@BHHS%,@@   rxxU3u EErV)rrc tj|}t|dd|jj t }|S)NrirrrqrrrrrrrrrSrrs rTrr!< == &!2!!??11qs1; =# *rVr"c tj|}t|dd|jj t }|S)NrirNrr r r s rTrr!r rVctj|}tj|j}|j |j j d}t |dd|S)NrirqrrNr )rr%primal_sharding_to_cotangent_shardingrrrr)rSrct_ss rT_one_vjpr !sW == & 3 3FOO D$ $))**b*9 :$ 1B1t <startrSx_lens rTruru!s= % a FE uu} %% UNEs,.clttj|}|Dcgc] }||vs| c}Scc}wrY)r itertoolschain)original removed_listsremovedrs rTrtrt!s0  / 0' 2'!1! 22 2s 11c.|?tjjy ttjjSt|tr(|t vrt|t|fS t|St|tr||fSt|ttfr|St|t tfr=t|dk(r/td|Drt!tttf|St|t tfrt|dk(rtd|Drvt!tttf|\}}t!tttft|d}t!tttft|d}||fSt dt t d |d #t$r8t dt t dtjjdwxYw#t$rYnwxYw) zTurns an API precision specification into a pair of enumeration values. The API can take the precision as a string, or int, and either as a single value to apply to both operands, or as a sequence of two values. NzBjax_default_matmul_precision flag must be set to None, a value in z3, or the name of a lax.DotAlgorithmPreset, but got rMc3<K|]}t|tywrY)rr/)rjrs rTrlz)canonicalize_precision..!"s 8Jq) $ 8rc3<K|]}t|tywrY)rrrs rTrlz)canonicalize_precision..$"s 21Jq#  2rrz9Precision argument must be one of: - None, - a string in z, - a lax.Precision value, - a tuple of two lax.Precision values or strings, - a lax.DotAlgorithmPreset or the name of one of these presets, or - a lax.DotAlgorithm value; but got rn)rdefault_matmul_precisionrrrrr-rrr/r[ru rLrrro type_cast)rs1s2p1p2s rTrr"s  &&,,4  #F$C$C$I$I JJ)S!&& y !9Y#7 77 !),,)Y' i )l,>?@ 9tUm,Y11D 8i 88 U9i/0) <<9tUm,Y11D 2 22 uS#X 2FB 5I-.0Fr0J KA NB 5I-.0Fr0J KA NB 8O./01  1 7   N $ % &'44::; =     s"G1HAH HHc ttt||t|t |tt||t |t|SrY)rgrr? r"rr )rSrr$s rTrxrx4"sB VHQNE!HfQi 8 HQNE!HeAh 7 99rVct|t|}}||k7r4tj||}||k(r t||}n t||}t ||SrY)r1rrtrrz)rr}a_dtypeb_dtype higher_dtypes rTr? r? 9"sXAYq 7' ''9Lw q' *a q' *a Aq/rVcJt|d}tj|||S)aCreate an empty array of possibly uninitialized values. This initialization is backend dependent. Args: shape: int or sequence of ints specifying the shape of the created array. dtype: dtype for the created array. out_sharding: (optional) :class:`~jax.sharding.PartitionSpec` or :class:`~jax.NamedSharding` representing the sharding of the created array (see `explicit sharding`_ for more details). Returns: Uninitialized array of the specified shape, dtype, and sharding. Examples: >>> jnp.empty(3, jnp.float32) # doctest: +SKIP Array([-5.7326739e+29 -7.7323739e+29 -3.14159256e-29], dtype=float32) .. _explicit sharding: https://docs.jax.dev/en/latest/notebooks/explicit-sharding.html z lax.emptyrqrbr)r:empty_prr s rTrrD"s%*'|[A, E\ JJrVrc2tj|||S)Nrxrr!r s rT_empty_abstract_evalr _"s  % >>rVctj|st||||Stj|tj r|nt j|}tj|||}tj|}tjtjjjt!|j"tj$|jggtjj&jdtjj(jd}t+|j,dk(sJ|j,d}tj.|||gS)Nr rxAllocateBufferF)call_target_namehas_side_effectrNr)rr& _empty_lowerrrr~rZrbr!rr5 CustomCallOpr(r3r rrrqrUrr rrr)rrqrbrr phys_avalcustom_call_oprs rT_empty_custom_call_lowerr c"s*   & 5L QQ$$UFOO<%"((5/%   eU\ B(  *)## ww## y !6!6y!GIJww))--.>?gg&&**51 . ^ # # $ )) )q!#  + +Ci @ AArVrrRctj|tjr|ntj|}t j |||}t j|}tjtjd|j}tj|||g}tj|||gS)Nrxrir) rrr~rZrbrr!rr(rrrr)rrqrbrrr rs rTr r v"s$$UFOO<%"((5/%   eU\ B(  *) "ioo67# c3 K#  + +Ci @ AArVct|d|j}|dntj||d}tj |||}|dfS)Nrr )rJrr'rr r) rvals_indims_inrqrbr batched_shapebatched_out_shardingr$s rT_empty_batcherr "sXua8-"d$$Y a@lle 46! A+rVc0tj||S)Nrbr)empty2_prr s rTempty2r "s U >>rVr c2tjd||S)Nri)rr r s rT_empty2_abstract_evalr "s  "e, ??rVcFtj|tjr|ntj|}t j t jd|}tjtj|j|jgSr%) rrr~rZrbrrr!r(rrrq)rrbrr s rT _empty2_lowerr "sh$$UFOO<%"((5/%  !1!1"e!<=)   288IOOY__E F GGrVtiec|SrYrir#s rTrr"sArVc|SrYrir#s rTrr"sQrVc|gSrYri)rrSr$s rTrr"srVc0tj||dfSrA)tie_pr)rFrGs rTrr"suzz73Xb\BrVc d|gSrYri)rgrSrs rTrr"s 4*rVctj|\}}tj|}t j |}tj ||S)aPrevents the compiler from moving operations across the barrier. Optimization barriers have a number of possible uses: * An optimization barrier ensures that every output of the barrier that is used by any operator, has been evaluated before any operator that depends on one of the barrier's outputs. This can be used to enforce a particular order of operations. Note that all operands must be used through the barrier for this to work. There are no ordering constraints between an operator that uses one of the barrier's outputs, and an operator that directly (not through the barrier) uses one of the barrier's inputs. * An optimization barrier prevents common subexpression elimination. This is used by JAX to implement rematerialization. * Optimization barriers prevent compiler fusions. That is, operations before the barrier may not be fused into the same kernel as operations after the barrier by the compiler. JAX does not define derivative or batching rules for an optimization barrier. Optimization barriers have no effect outside a compiled function. Args: operand: a pytree of JAX values. Returns: A pytree of JAX values, with the same structure and contents as ``operand``. Examples: Prevents common-subexpression elimination between the two calls to `sin`: >>> def f(x): ... return jax.lax.optimization_barrier(jax.lax.sin(x)) + jax.lax.sin(x) >>> jax.jit(f)(0.) Array(0., dtype=float32, weak_type=True) )rrrroptimization_barrier_prr)rrrrs rToptimization_barrierr "sML!--g6)W(()4)##Y/#  ! !'3 //rVc2tjdg||S)Nr )rrq)rs rT#_optimization_barrier_abstract_evalr "s/7$7 +rVcttj|j}tj|}t j |}tj|j|SrY) rr(rrrr5OptimizationBarrierOpunflatten_ir_values_like_typesr)rr barrier_typesr barrier_ops rT#_optimization_barrier_lowering_ruler "sQd**CLL9-$$T*)((3* , ,Z-?-? OOrVr c 0tj|i||fSrY)r r)rrrhs rT_optimization_barrier_batcherr "s  $ $l =f =z IIrVc||Dcgc]}tj|}}t|t|fScc}wrYr&instantiate_zerosr )rFrGrs rT_opt_barrier_jvpr "s;/7 8!b""1% 8( 8 g &(rWrr?r)ruzSequence[Shape])rutuple[int, ...]rrr?r )rSr=r?r<)rur r?r )rutuple[int | core.Tracer, ...]r?r )rr=rr=r?r<)rSr=rrr?r<rY)rSr=r$r=r?r<)rSr=r$rr?r<)rr=rz DTypeLike | dtypes.ExtendedDTyper?r<)NFNT) rz!ArrayLike | literals.TypedNdArrayrz DType | NonerrrSharding | Nonerr)rr=rrAr?r<)r^r=rSr=r`r=r?r<) rrrtree_util.PyTreeDefrzSequence[core.AbstractValue]rrrcore.DebugInfor)rrrrrr) rmlir.LoweringRuleContextrrrrrz:Sequence[tuple[str, tuple[Any, ...], tree_util.PyTreeDef]]rrrcore.ClosedJaxpr)r#zArray | Sequence[ArrayLike]r!rr?r<)rr=r(rr)rr?Sequence[Array])NN) rr=rr=rrr PrecisionLikerrr?r<) rr=rr=rzDotDimensionNumbers | Nonerr rrr?r<)NNN)rr<rr<rr<rr rrr Array | Noner?r<)rz/RaggedDotDimensionNumbers | DotDimensionNumbersr?r)rr<rr<rr<rrrr rrrr r?r<)rr=r(rr?r<)rr=rqrBrrr?r<)rSr=rrr?r<) rr=rrBrzSequence[int] | NonerNamedSharding | P | Noner?r<)rr=rr=rzSequence[tuple[int, int, int]]r?r<)rr=rrr?r<)rr=rr=rr=r?r<)rr=rr=r?r<)rr=rzSequence[int] | np.ndarrayr?r<)rr=r)rrrAr?r<) r#rrrr r[ rrrr r?r)r rrzcore.AbstractValue)r r[ rr r+r )r=rr>r r?zCallable | None)rbrAr?z np.ndarray)rr=rrr?r<)rTrN) rr<r!rrerrfrr?r<) rr r!rrerrfrr?ztuple[Array, ...]) rzArray | Sequence[Array]r!rrerrfrr?zArray | tuple[Array, ...])rT) rmr<rr=r!rrerr?tuple[Array, Array])rr=rrr)rr?r )rSrr$rKr?rK) rqrBrr=rbrrr r?r<)rr!r?r<)rzstate.AbstractRefr?zcore.Ref)rbrArrr?r<)rbrArqrBr!rr?r<)rbrArqrBrr>r?r<)rbrArqrBrrr?r<)rSrKr?rK)rzfloat | ArrayLikerrrrr?r<)rr=rrr?r<) rSzArrayLike | DuckTypedArrayrr=rbrrqz Shape | Nonerr r?r<)rr<rrr int | Noner?r<)rr<rr<rr r?r<)T)FTNN)rzcore.ShapedArrayrzSequence[core.ShapedArray]rSequence[ir.Value]r?r )r$rrzir.Valuer?r )rr)rrrr)rr)rrrr)r?zpp.Doc)rr/r?ztuple[Precision, Precision])rr/r?z ir.ArrayAttr)rCanonicalPrecisionrVrArWrAr?r) rz!DotAlgorithm | DotAlgorithmPresetrVrArWrArrr?z;tuple[DTypeLike | None, DTypeLike | None, DTypeLike | None])r?zhlo.ResultAccuracyAttr)rnp.dtype | Nonerr)rrrrr?ztuple[RaggedDotMode, int])rrrrr?r)rrrrr?r) rr<rr<rr<rrrrr?znp.dtype)rrrr )rr rr rr)r?r )rqz core.Shape)rr rr )rr )r+ r=r?r<)rr7r?r )rrrr!r?None)F)r?r)rr r?r ( __future__rrcollections.abcrr dataclassesrrrr rrtypingrrr r r r r rnumpyrZjax._srcr rrrrrrrrrrrrrrpprrrrjax._src.abstract_arraysr jax._src.corer r!r"r#jax._src.errorsr$jax._src.hashable_arrayr%jax._src.interpretersr&r'r(r)rr*r/r+r,r jax._src.meshr-r.jax._src.lax.utilsr/r0r1r2jax._src.lib.mlirr3jax._src.lib.mlir.dialectsr4r5jax._src.shardingr6jax._src.sharding_implsr7r8r9rr:r;jax._src.typingr<r=r>r?r@rArB jax._src.utilrCrDrErFrGrHrIrJr`rr^rrrrKr unsafe_mapr unsafe_zip set_moduleexportrUrdrvrrrrrrrrrrrrIntEnumrrrrrEnumrrrr rrrrrr r%r(r,rr2r5r8r=r@rDrGrJrMrQrTrWrZr]rardrgrjrqrtrwrzr~rrrrrrrrrrrrrrrrdef_impldef_abstract_evalrprimitive_jvpsprimitive_transposesregister_loweringr%r,r-rYr/rrArrLr[rrr r rrrrr dataclassrrrrrrrrrrrrrPrr r&rrr6r4rGrJr9r;rr3r:r<r5r7r8rgrnrurwrzraval_zeros_likersr AbstractRefrrrrrrrrrrrrrrrrrrrrr r r aval_methodr staticmethodrr!r python_scalar_typesrtyped_scalar_typesrraw_jaxval_adders _fixed_dtype_complex_basetype_strip_weak_typer;rBrM standard_unoprIrYr[rrmrustandard_naryopr~rrrrr r1rr2rDri_complex_elem_typesr1r0r0_boolr _signedintr^ _any _bool_or_int_orderedr deflinear2negater defjvp_zerorr next_afterrrrrrrdefjvp2r pp_eqn_rulesrrrdefjvpr exponential_minus_oner log_plus_onerrrrrrrrprimitive_linearizationsrrrrrrrrr"rrrr rr'r+rrr.r0r r  linear_jvpr4rrrr?rCrFrrrr7r%r'r-r3r6r<rJr9r=rrInot_rLrrPor_rSrBrVpopcntrYcount_leading_zerosrKrNrXr\rZr\r`r rarc defbilinearrrkrfr;ri remainderrurlmax_hlornmin_hlorprsrvrAndOprOrOprrrryr}rrrrr r r rrrrrrrrrrrrrrrqrrdef_bind_with_tracerG rfancy_primitive_batchersskippable_batchersconst_fold_rulesforwarding_rulesrrrrrrrrrrrrr-r"r=rKrFrVrXr1rirarerrrrrrrr_dot_general_batch_rulerrrrrrrrrrrrrrrrr rr r#r&r)rrMrQr[rarerjrqrsrxr|r~rrrcustom_partial_eval_rulescustom_staging_rulescustom_typechecksrr_clamp_dtype_rulerrprimitive_batchersrrrrrrrr"rrrrrrrrrr*rrrrrrrr rrrr rr"rr$r'r,r6r9rIr@rRrArBrZr\rarcrergrrjrlrprrtrxr{r~rrrrrrrrrrrrrrrrrrrrrr rr r r r! r r( r- r3 r5 rR defreducerr: r= rUrB rXr[rE rH rJ rL r^ rr ra rc rg r]r_rbrAddOpMulOpXorOprm ro r deflinearrr rbr rr _UINT_DTYPESint16rr _INT_DTYPESr r r r r r r rkr r r r rtr r r rr r r r r r r r r r r r r r r r r r<r r& rZ r, r2 r4 rE rH r* rO EffectrQ rT control_flow_allowed_effectsadd_typelowerable_effectsrN def_effectful_abstract_evalr r' r_ rra rc re rO_ndimri rl rn r r rVrXrrrr"rr r r r1r r rurtrrxr? rr r r r r r r simple_implr r r r r r r r r r rirVrTrw sB#.  OO!&)%0//11$*&4& +>!+*&ZZ^^^222||||    CLCZCZ  #D= '6 P F F =7= =(/(/T- -^&G* &((T""<(( T\\ ,:,I,I!:)!:!:!:F("499**6+8,,8**2,,8++6//$**:**:0**2//2&2$$*++4,,6++4.444$$(&...:622!!2--4**4<<<<<<"D$D"DIN"D"DL# $)- D .DDD D #' DL C CD #(':((D(%((+9 ((,dd ddN6 !6 6 6K 6  6  6r) dnn[) _% 67# !.+': ${$78<4BB+B(,.(-# #L!* 1 19 ) 1 19&^^6$-NN=!&/nn?# ) 1 19!*!2!2: ) 1 19$,,4W:WteeP  #s(O )Y    )Y E(3-#">?!(3-#">?@A,0;? W " W#6 W( W)9 W ', W"9=#'37 m75m7 m7!1m7$ m7h $/3!%     -    @d#MM$M6J'@C!:Bx0#'# $/3!%= = ==#< =  = - == =@IM55,KOO+8OOB,04<8<<,<5<AF<|:R6:R;@:Rx;26(6 >5 >:? >G!G&+G G!G&+G59 -3-31-3%-32 -3>A -3^- * 5*8 5*= 5  5+0?6$ < <!Q%*Q8746*6*5,6,6, *,12BB+.B7<B B 4612NN+.N7HN N=?12#Y#Y+.#Y7P#YJCE#' ,?68'/R %(%)%("%(.3%(N **A+&0G%++,-&* A.3 A4 /4$4%l >$' >$' >,1 >6 ?&@DFJ6 #6 ,<6 !6 4C6 OT6 t+/%'%38%:-1 *) *5: *&**8&&(&&&&,)((3 (((3 &d&&w/  Q!'    eoo->  !-A"-'A-: M+*.,.Ri( ? $(e(63*/XA6FKGK &+. R$ K  'A  !3 026 A A& A AE ++    zz2::. |     f}x f}x%'e| &=5 dE"  e01ugoszzBC tV $vv/vv. < {GOT__$MN  (ww CD vv &vvwAB  (w' w -<)6;? {{GOS]]$KLfx'/  59:ugosGH7% v(& 1   Kv{+8&fx'/  %12ugosww?@7% )7 3   w0I0IJL9' )7 3  'ABw9I9I JK9' v(& 1   5 vwAB8& 6H,j 9  /) z%t~~meLN <*G >* fx'/  %IJ%-E"um,7% G@ fx'/   Hum,7%fx'/  5TUugosww?@7% v(& 1  &JKvw BC v(& 1  &OPvw BC  v(& 1  &CDvw BC 6H,fx.?@' J  ' C HJw CD v(& 1  &./vw BC v(& 1  &./vw BC )7 3  'FGw DE )7 3  ' >?w DE )7 3  ' PRw DE 6 2  fHIvwAB 6 2  fMNvwAB8$B >$79L#M   i01y'/3;;"GH n1H"' )ugosww?@.   5- 7 7 v(& 1  6OPvwAB8& )7 3   Iw CD9' vv &    vwAB8& 18 <   8CDx!23 < (!2D6MH4L M% 1$P  5, -/uj)S# g/J'+e2DF }%  -)*?$A"}&;<B lE*uugosxx@A|4e<uugosxx@A l3T:ttW_cgg>?|4e<uugosww?@"4);<)7?CJJ+OPdE"ugos7N7NOP ' >U,+d|U)<>y>#%!/ugosww?@ ' C t e,#%!/ugos||DE5: t e   SLNugos}}EF(t e<~<  5 ? ?Augot||DE't e<~<  5 ? ?Augot||DEd|\: ||W_cnn%MN*D$<9QR'(/0J0JKM(t 6KL$%,0G0GHJ ;D#))-FHD#((,DF N; l288$tTlDtTttW%7uEF l288$tTlDtTttW%7uEF l288$x&:DAttW%7uEF l288$x&:DAttW%7uEF l288$x&:DAttW%7uEF l288$x&:DAttW%7uEF bhh'$w ?ww(:D$ GH bhh'(H)=w Gww(:D$ GH bhh'(H)=w Gww(:D$ GH 2 .  O JJ   . E ,$&F+O5 T++-C D73 5**+PQ(@(@BX YZ  !#AB2V./Q =`!!"896B23.L*+.H*+,E()4 A-/JK3j $ WX55{CD 67  + NOG ${#{$:;6-( wx77GH  :;  - MN@ &}%}&<=( D ,$&F+;5 T++-C D F %&-.A -/JK&4?Q4D?QB ?( )E7G)EVW0A7H:4D:03::  7<7G47G&'-&'RE1NM#, T++] ;.*   })+EG+)++""  4K!!-0-9M*#7-   >"+>0G>#' (0((( ( A (8 F6V6?:I/26}&89,H$ !3hG"*,, DII 1J.MM1JMM 1J  .W-Wt  #<  - 40!fh-hhV ('-':*"" T++\ :  +G&'0R,-:X!!"674@01 $/3!%d d dd#< d  d - dd d`"&9,999x+%t~~&>7<>?H$ '(;"H I 8&B A);A D$T^^$67$$%DEGH$<$<>PQR(B$%.N*+8T!!"452>./*D&'3Q/0.L*+-M)*)+BC-{T4. D&; ,i( T++Y 7&  (  i01)<I&A y.1 ( (VA ;2 020(02 /  AB 24G(8N(/0F0F (R T  i01/B!!),)5I&y.1$;y!%: "  , ?K);$+D,B,BE$J L eBC%4E"Auj)BJ 2.,A!; * T++[ 9,( *  kOQ+@K({$45 ")"($T (4 @D *J)9N T++Z 8: !,*&< #0B!!*-*6J'z#78J# ( G *2B N 4>>( # '(22H=> /;M  68M );H%.(>&6>.x/ %E 9=H0 ."!:LI7 4))< 8+' )  l67L"34) 0 #!:MJ7 4))= 9; $9- M#56D"; * T++\ :<   <12L"34"; * T++\ :<   <12L"3406  880  35J&7G,D'.t/E/Ex'P RH/0x 35J&7G,D'.t/E/Ex'P RH/0x DNN"B(9:   DNN"B(9:  / Q7 ! [#3P T++[ 9; K!9:+9K(" \#3P T++\ :< L";<" \#3P T++\ :< L":; G|W-@#))->&@A}g.A399.@'BC{G,?,D%FG|W-@#))-F&HI|W-@#))-E&GH|W-@$,,->&@A|W-@$,,->&@A(  OY0BC +J T++-? @ B   ![\)*A )+BCbhhryybhhryybhhryy bhhrxxbhhrxxbhhrxx   0-. -. +,$:4$ 6 00&9:,-%&&6F#.v{+A8T.6 G 117;<./8w -'''8G$=  .E'))*7PG334>* 8 8.IJ !:;~'=>%  $ WX55{CD 67#{$78 6 ;-( wx77GH  :;H }&;<#&  $dll $;7Kt 34'+$ H $ $&9:<%% /1D )+H -/O ')* *24:&9   F+,%v12  V/0v+'.. $$--k:"";/ T^^J ' L!"  &&'FGz#45  Z&*?J'(* / ; ;&&*&8 6 6 00&9:,-D #5"6vA v{+ 6/$)) ")L55(5 95 5  ( 5  9 5 (5 95 9555 55 &5 &5 !5"#5$ &%5&'5()5*+5, 7-5. 7/50 Y152?354 &556 75895:;5<=5> ?5@A5B 7C5DE5FG5HI5J K5LM5N{O5PQ5R 7S5T GU5V W5XY5ZM[5\ &]5^_5` &a5b &c5de5fg5h &i5nN$F0F933 )2x2 = )2x2";h;,,x<<:3 .b9 )-K0 $.. !117;<?./B w 8%@w 8%@Bw -.<!!'*? 4>>( #X@01Hx/ u~'u34B%!<u)0XP((>?*.' H $ $&<=?(()LM-:<J6S23G-=()#3I./rV