ukit ddlmZddlmZmZddlmZddlZddlm Z ddl Z ddl m Z ddl Z ddl ZddlmZddlmZdd lmZdd lmZdd lm Zdd lmZdd lmZddlmZddlmZmZddlmZmZddl m!Z!ddl m"Z"ddl m#Z#ddl$m%Z&ddl$m'Z'ddl$m(Z)ddl*m+Z,ddl*m-Z.ddl/m0Z0m1Z1m2Z2ddl3m4Z4ddlm5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;me:Z?e:Z@e:ZAeeBZCejZDejZEddZFdd  dd!ZGd"ZHdd$ZId%ZJGd&d'ZKe eLeKeDefZMdd(ZN dd)ZOdd* dd+ZPdd* dd,ZQdd-ZRdDdd.ZSdDdd/ZTdd0ZUdd1ZVdd2ZWdd3ZXdd4ZYdd* dd5ZZdd6Z[d7Z\ ddd8 dd9Z]d:Z^ ddd8 dd;Z_ed<=dd>Z`dd?Za ddd8 dd@Zbed<=ddAZc ddd8 ddBZddCZeedD=ddEZf d ddHZg ddd8 ddIZhedJ=ddKZiedJ=ddLZj d ddMZkedN=ddOZl ddd8 ddPZmed<=ddQZn ddd8 ddRZoed#dGgSddTZp d ddUZqddVZr d ddWZsedJ=ddXZt d ddYZuedZ=dd[Zv d dd\ZwedJ=dd]Zxdd^Zyd_Zzdd`daZ{dbZ|ejdcZ~e~je{ddZe~jee!je~ddee#je~e#jee{dF`dfe#je~e#jee{dF`dfdghe|e"j e~< d ddiZ d ddjZedkSdddlZedm=ddnZedm=ddoZedZ=ddpZ d ddqZ ddd8 ddrZeds=ddtZ d dduZ d ddvZedJ=ddwZ d ddxZedJ=dyZ d ddzZedZ=dd{Z d dd|ZedZ=dd}Z d dd~ZedZ=ddZ d ddZed<=ddZ d ddZedJ=ddZ d ddZedJ=ddZ d ddZed<=ddZ d ddZed<=ddZ d ddZ d ddZ d ddZ d ddZedZ=ddZ d ddZedZ=ddZ d ddZedZ=ddZ d ddZeddFddZej^dddf ddZedZdFddZdZedNdFdZedNdFdZed-@AKG ##v'@'@'F'FF  9 ::    % %)B)B)G)G Gmm 9EFH  " " ( (mm 5  /S {; << [-- v!xx}o-OQ RR g r.ctj|jtjsJtj j r|S|rtj|S|Sr() r r8r9r:r rEr>r random_unwrap) was_wrappedrMs r,_return_prng_keysrTksL   399foo 66 6 $$ J&14  c ":s:r.rKctj|jtjsJt j |||S)N bit_widthrK)r r8r9r:r random_bits)rMrWrKs r, _random_bitsrYts5   399foo 66 6  #% @@r.ctjj}|tjvsJ|tj|S)zGet the default PRNG implementation. The default implementation is determined by ``config.jax_default_prng_impl``, which specifies it by name. )r r<r>rprngs) impl_names r,r<r<{s; &&,,) djj +)+ I r.cHeZdZUdZdgZded<dZd dZd dZd dZ d dZ y ) PRNGSpecz$Specifies a PRNG key implementation._implPRNGImplc||_yr()r_)selfr3s r,__init__zPRNGSpec.__init__s DJr.c6d|jjdS)Nz PRNGSpec())r_rLrbs r,__repr__zPRNGSpec.__repr__s tzz) ++r.c,t|jSr()strr_rfs r,__str__zPRNGSpec.__str__s tzz?r.c,t|jSr()hashr_rfs r,__hash__zPRNGSpec.__hash__s  r.cXt|txr|j|jk(Sr()r7r^r_)rbothers r,__eq__zPRNGSpec.__eq__s! eX & D4::+DDr.N)returnri)rqint)rqbool) __name__ __module__ __qualname____doc__ __slots____annotations__rcrgrjrmrpr.r,r^r^s+,i) /,Er.r^c| tSt|tur|St|tur |jSt|t urk|t jvrt j|Sdjdt jjD}td|d|dt|}td|d)Nz, c3(K|] }d|d yw)"Nrz).0ss r, z$resolve_prng_impl..s=a1QCq=sz"unrecognized PRNG implementation "z". Did you mean one of: ?zunrecognized type z$ for specifying PRNG implementation.) r<rHr`r^r_rirr[joinkeysrArG) impl_speckeys_fmtts r,resolve_prng_implrs   )_  )_ ?? )_DJJ ZZ ""yy=4::??+<==H 9)E--5Ja9 :: 9o!&qc)MNOOr.cHt|}t|dr`_ section. When possible, :func:`jax.random.key` is recommended for use instead. The resulting key does not carry a PRNG implementation. The returned key matches the implementation given by the optional ``impl`` argument or, otherwise, determined by the ``jax_default_prng_impl`` config flag. Callers must ensure that same implementation is set as the default when passing this key as an argument to other functions (such as ``jax.random.split`` and ``jax.random.normal``). Args: seed: a 64- or 32-bit integer used as the value of the key. impl: optional string specifying the PRNG implementation (e.g. ``'threefry2x32'``) Returns: A PRNG key, consumable by random functions as well as ``split`` and ``fold_in``. TPRNGKey)rTrrs r,rrs4 4it!< ==r.ctd|\}}tj|r"tdtj|dt j |tj|d}t||S)acFolds in data to a PRNG key to form a new PRNG key. Args: key: a PRNG key (from ``key``, ``split``, ``fold_in``). data: a 32-bit integer representing data to be folded into the key. Returns: A new PRNG key that is a deterministic function of the inputs and is statistically safe for producing a stream of new pseudo-random values. fold_inz9fold_in accepts a scalar, but was given an array ofshape r6uint32r9) rPrJrIrGrKrrandom_fold_injnpasarrayrT)rMdatarOkey_outs r,rrst!C0,#wWWT] XXd^,,NP QQ   S[[X%F G' 7G ,,r.ctj|jtjsJ|jrt d|j dt|tr t|n|f}tj||S)Nz?split accepts a single key, but was given a key array of shape r6rK) r r8r9r:rIrGrKr7rtupler random_split)rMnumrKs r,_splitrsx   399foo 66 6XX  YYK'IK LL"31%*v%  3e ,,r.cLtd|\}}t|t||S)aKSplits a PRNG key into `num` new keys by adding a leading axis. Args: key: a PRNG key (from ``key``, ``split``, ``fold_in``). num: optional, a positive integer (or tuple of integers) indicating the number (or shape) of keys to produce. Defaults to 2. Returns: An array-like object of `num` new PRNG keys. split)rPrTr)rMr typed_keyrOs r,rrs)'w4)W 7F9c$: ;;r.ctj|jtjsJt j t j|j}|jSr() r r8r9r:typingcastrKeyTyr_)r keys_dtypes r, _key_implr(sD   4::v 77 7{{4::tzz2*   r.c~t|}|jtjvr |jSt |Sr()rrLrr[r^)rr3s r, _key_specr-s- 4$ii4::-A8D>Ar.c:td|d\}}t|S)Nkey_implTr/)rPr)r typed_keys_s r,rr1s!*d$G-*a : r.ctj|jtjsJt j |Sr()r r8r9r:rrR)rs r, _key_datar6s1   4::v 77 7  D !!r.c:td|d\}}t|S)z9Recover the bits of key data underlying a PRNG key array.key_dataTr/)rPr)rrs r,rr:s JD A'$ 4r.cFt|}tj||S)aWrap an array of key data bits into a PRNG key array. Args: key_bits_array: a ``uint32`` array with trailing shape corresponding to the key shape of the PRNG implementation specified by ``impl``. impl: optional, specifies a PRNG implementation, as in ``random.key``. Returns: A PRNG key array, whose dtype is a subdtype of ``jax.dtypes.prng_key`` corresponding to ``impl``, and whose shape equals the leading shape of ``key_bits_array.shape`` up to the key bit dimensions. r2)rrr;)key_bits_arrayr3impl_objs r, wrap_key_datar@s!t $(  .x 88r.c||r:tj|g|}||k7rd}t|j|||yy)Nz{} parameter shapes must be broadcast-compatible with shape argument, and the result of broadcasting the shapes must equal the shape argument, but got result {} for shape argument {}.)rbroadcast_shapesrAformat)rLrK param_shapesshape_msgs r, _check_shaperUsM  ! !% 7, 7F Lc szz$6 77 r.c ft|fi|}||St|||jjS)N) out_shardingaxes)rr mesh explicit_axes)fr hoist_kwargsf_s r,maybe_auto_axesr_s<q!L!" I Rl&++99 ;;r.)rcptd|\}}|tj}ntj|}tj|t j std|tj|}t|d|}|jdz}tt||||S)aSample uniform bits in the form of unsigned integers. Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default ``()``. dtype: optional, an unsigned integer dtype for the returned values (default ``uint64`` if ``jax_enable_x64`` is true, otherwise ``uint32``). Returns: A random array with the specified shape and dtype. bitsz @@r.czt||}t}|jr||st|t }|Sr()r!rare_all_axes_explicitrP)rrLrKcur_meshs r,rrs:&|T:,  ( ## (>> val = jnp.uint32(0xFFFFFFFF) >>> val.astype('int32') Array(-1, dtype=int32) This function clips to the values representable in the new type: >>> _convert_and_clip_integer(val, 'int32') Array(2147483647, dtype=int32) z6_convert_and_clip_integer only accepts integer dtypes.)r7r"r r8rJintegerr9rGr_constriinfominrclipastype)valr9min_valmax_vals r,_convert_and_clip_integerrs2 C     E2:: .63D3DSYYPRPZPZ3[ L MM JJsC U 3 7 7 & SYY 7 ; ;= >' JJsC U 3 7 7!'cii!8! ?' #w ( / / 66r.ctd|\}}tj|tn|}t j |}t |d|}tj|tjstd|tjjrtj|}|}|jdkrtj d}t#j$|j'dj)t|j*t|j,}t#j$|j'dj)t|j*t|j,dz}t/t0||||||j'|St/t0||||||S)aSample uniform random values in [minval, maxval) with given shape/dtype. Args: key: a PRNG key used as the random key. shape: a tuple of nonnegative integers representing the shape. minval: int or array of ints broadcast-compatible with ``shape``, a minimum (inclusive) value for the range. maxval: int or array of ints broadcast-compatible with ``shape``, a maximum (exclusive) value for the range. dtype: optional, an int dtype for the returned values (default int64 if jax_enable_x64 is true, otherwise int32). Returns: A random array with the specified shape and dtype. .. note:: :func:`randint` uses a modulus-based computation that is known to produce slightly biased values in some cases. The magnitude of the bias scales as ``(maxval - minval) * ((2 ** nbits ) % (maxval - minval)) / 2 ** nbits``: in words, the bias goes to zero when ``(maxval - minval)`` is a power of 2, and otherwise the bias will be small whenever ``(maxval - minval)`` is small compared to the range of the sampled type. To reduce this bias, 8-bit and 16-bit values will always be sampled at 32-bit and then cast to the requested type. If you find yourself sampling values for which this bias may be problematic, a possible alternative is to sample via uniform:: def randint_via_uniform(key, shape, minval, maxval, dtype): u = jax.random.uniform(key, shape, minval=minval - 0.5, maxval=maxval - 0.5) return u.round().astype(dtype) But keep in mind this method has its own biases due to floating point rounding errors, and in particular there may be some integers in the range ``[minval, maxval)`` that are impossible to produce with this approach. randint)randint only accepts integer dtypes, got rint32r)rPr rrrr rrr8rJrrGr safer_randintr>rrr9rrrrrrr_randint) rMrKrrr9rrinfodtype_for_samplings r,rrssV 9c *&#q  2 2 ]c '%  ! !% (%3L)US,   5"** - ?wG HH  << D yy2~88G,{{6"))'277DHH s488}Uf{{6"))'277DHH s488}WXGXYf Y?8\FX Y VV #VE]+ Kz_randint..ysl3u5r.rr4)rrJrKr r8rrGrrrr9rrrrgtrrrrrrrrrrselect full_likeaddrremmul)rMrrrKr9maxval_out_of_rangek1k2rbits higher_bits lower_bitsunsigned_dtypespan multiplier random_offsetrs ` @r,r r Hs&y%&!1288F3CD   5"** - ?wG HH)VV, ;;v & ;;v &   6<< 4 ]]3 F   6<< 4 ]]3 F %cii U0C0G0G&OQWQ]Q] ^` %VU 3& $VU 3&  U 4&  U 4& ,,u  " "% /! OPUwW XX #;&"b 5%!"IuRyz+u%. ! !&6/> B$ Ff$cmmD!&.sxSZZ]D'Ir.)r% independent)rPrr&rJrIr!r8rr9rrGr concrete_or_errorrrr _permutation)rMr+r%r'rrr&s ` @r,r!r!s& =# .&#q-# 4q 1$&|]C,  ==1rzz 2 F GG sA'OPA )?I' )), .. FLt FFI1 NNr.c|stj|dk(r t|||St|tj|j |d}tj |||dS)NrrT)unique_indices)rJrIr#rr$rKtake)rMr+r%r'inds r,r)r)sVBGGAJ!O CD !!cjj/3# !S$t 44r.r4c ,d}tjtjj}t j |jstd|jttj|tjt d|jztj|z }t|D]A}t|\}}t|d|j}t!j"|||\}}C|S)NrzSshape polymorphism for `permutation` or `shuffle` for arrays of non-constant size: rr)r rrJrrr is_constant_dimsizeNotImplementedErrorrrceillograngerrYrKr sort_key_val) rMr+r%exponent uint32max num_roundsrsubkey sort_keyss r,r#r#s (ll299%)))  aff %  --.VVH 6 772778bffSAFF^&<r>sN 8S )&#q E8 $  '# $$(A A#XX]%%c1.YZH T388 ,DyyH IIe ' \ 99U#)) ,, ] K LL Wx'  ,WI6$:%; = >>Y C8 ,chh!ms#sD)Afd ~$g'88f3CHHMsDI&QfHa #A &FE {{xk!   %;H:Q H IIzz% f *GCfllCC Da   VQ ' . .s 3c xk4 @3775> Qa IIa7 #A & - -c 2cHHMSsxxS$'?F Q OO !D)E%L8399T!VW;MM OOr.c4td|\}}tj|}t|d|}t j |t n|}t j|tjstd|tt||||S)aYSample standard normal random values with given shape and float dtype. The values are returned according to the probability density function: .. math:: f(x) = \frac{1}{\sqrt{2\pi}}e^{-x^2/2} on the domain :math:`-\infty < x < \infty` Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified shape and dtype. normalzAdtype argument to `normal` must be a float or complex dtype, got r) rPr rrr rrr8rJinexactrAr_normal)rMrKr9rrs r,rUrU7s0 8S )&#q  ! !% (%3L(ER,  2 2}e% )%   5"** - !7$ %% I,e5 I# NNr.)rr4ctj|tjrtjtj d|}t |\}}tjd|jj}t|||j|}t|||j|}|d|zz|z St|||S)Nr4ry?) r r8rJcomplexfloatingrsqrtrrealr9 _normal_realr) rMrKr9sqrt2key_rekey_im real_dtype_re_ims r,rWrWYs ub001 HHRWWQZ 'EC[NFF!U#((..J vuj 1 8 8 ?C vuj 1 8 8 ?C "s(Ne ## UE **r.ctd|tjtjd|tjd||}tjd|}t |||||}t j tjtjd|tj|S)NrUrrr4) rrJ nextafterrrrrrZ lax_specialerf_inv)rMrKr9lohius r,r\r\fsx ||BHHS%("((2u*=UK" xxE" c5%R(! "''!*e,k.A.A!.D EEr.cVtd|\}}t||\}}|dvr td| |j}nt j |}t j |tjstd||tj|}t||||||S)a0Sample multivariate normal random values with given mean and covariance. The values are returned according to the probability density function: .. math:: f(x;\mu, \Sigma) = (2\pi)^{-k/2} \det(\Sigma)^{-1}e^{-\frac{1}{2}(x - \mu)^T \Sigma^{-1} (x - \mu)} where :math:`k` is the dimension, :math:`\mu` is the mean (given by ``mean``) and :math:`\Sigma` is the covariance matrix (given by ``cov``). Args: key: a PRNG key used as the random key. mean: a mean vector of shape ``(..., n)``. cov: a positive definite covariance matrix of shape ``(..., n, n)``. The batch shape ``...`` must be broadcast-compatible with that of ``mean``. shape: optional, a tuple of nonnegative integers specifying the result batch shape; that is, the prefix of the result shape excluding the last axis. Must be broadcast-compatible with ``mean.shape[:-1]`` and ``cov.shape[:-2]``. The default (None) produces a result batch shape by broadcasting together the batch shapes of ``mean`` and ``cov``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). method: optional, a method to compute the factor of ``cov``. Must be one of 'svd', 'eigh', and 'cholesky'. Default 'cholesky'. For singular covariance matrices, use 'svd' or 'eigh'. Returns: A random array with the specified dtype and shape given by ``shape + mean.shape[-1:]`` if ``shape`` is not None, or else ``broadcast_shapes(mean.shape[:-1], cov.shape[:-2]) + mean.shape[-1:]``. multivariate_normal>svdeighcholeskyz1method must be one of {'svd', 'eigh', 'cholesky'}zCdtype argument to `multivariate_normal` must be a float dtype, got ) rPrrAr9r rr8rJrr r_multivariate_normal)rMmeancovrKr9methodrs r,rmrmosH 0# 6&#q$T3/)$ .. H II ] JJE  4 4U ;E   5"++ . ##('+ ,,   # #E *E c4eUF CCr.)rrcztj|dk\s/d}t|jtj|tj|dk\s/d}t|jtj||jd}tj|dd||fk7r1d}t|j|tj||1t j |jdd|jdd}n(td ||jdd|jdd|d k(r:tj|\}} } |tj| d dddfz} nS|d k(r9tj|\} } | tj| d dddfz} ntj|} t|||jddz|}tj d 5|t#j$d| |z}ddd|S#1swYSxYw)Nrz@multivariate_normal requires mean.ndim >= 1, got mean.ndim == {}r4z>multivariate_normal requires cov.ndim >= 2, got cov.ndim == {}r?z^multivariate_normal requires cov.shape == (..., n, n) for n={n}, but got cov.shape == {shape}.)nrKrUrn.roallowz...ij,...j->...i)rJrIrArrKrrr jnp_linalgrnrrZrorprUr numpy_rank_promotion jnp_einsumr)rMrrrsrKr9rtrrxrkrrfactorwvnormal_samplesrOs r,rqrqs !  LC SZZ . //   JC SZZ - .. jjn!XXc]23Aq6! +C SZZ!288C=Z9 :: ]  CR#))CR. AE5$**Sb/399Sb>B u_s#IQ1 !CqL/* *F  __S !FQ !CqL/* *F   %F#utzz"#6>. ""7+R J%%&8&.Q QFR -R -s H00H:c:|tj|}td|\}}t|d}t j |t n|}t j|tjstd|tt||||||S)aSample truncated standard normal random values with given shape and dtype. The values are returned according to the probability density function: .. math:: f(x) \propto e^{-x^2/2} on the domain :math:`\rm{lower} < x < \rm{upper}`. Args: key: a PRNG key used as the random key. lower: a float or array of floats representing the lower bound for truncation. Must be broadcast-compatible with ``upper``. upper: a float or array of floats representing the upper bound for truncation. Must be broadcast-compatible with ``lower``. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``lower`` and ``upper``. The default (None) produces a result shape by broadcasting ``lower`` and ``upper``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and shape given by ``shape`` if ``shape`` is not None, or else by broadcasting ``lower`` and ``upper``. Returns values in the open interval ``(lower, upper)``. truncated_normalz@dtype argument to `truncated_normal` must be a float dtype, got r) r rrPr!r rrr8rJrrAr_truncated_normal)rMlowerupperrKr9rrs r,rrsB   # #E *E -s 3&#q&|5GH,  2 2}e% )%   5"++ . ##('+ ,, 3*L$E 336u FFr.c |=tjtj|tj|}n4t d|tj|tj|tj tj d|}tj||}tj||}tj||z }tj||z }tj|tjs tdt|||||}|tj|z} t!j"| tj$tj&|tj tj(|tj$tj&|tj tj( |S)Nrr4z4truncated_normal only accepts floating point dtypes.rrr)rrrJrKrrrZrrgerfr r8rrGrrhrrrf stop_gradientinf) rMrrrKr9r]rIbrkouts r,rrsY ]  %"((5/ BE#UBHHUORXXe_M ((2771:u %% " "5% 0% " "5% 0%ooeem$!ooeem$!   5"++ . J KK c5%!4! ##A&&#   mmC%%e,bhhrvvU.KL mmC%%e,bhhwe.LM OOr.c|tj|}|dvrtd|dtd|\}}t |d}t j |}tj|tjsd}t|j|t j||}tt|||||S)aTSample Bernoulli random values with given shape and mean. The values are distributed according to the probability mass function: .. math:: f(k; p) = p^k(1 - p)^{1 - k} where :math:`k \in \{0, 1\}` and :math:`0 \le p \le 1`. Args: key: a PRNG key used as the random key. p: optional, a float or array of floats for the mean of the random variables. Must be broadcast-compatible with ``shape``. Default 0.5. shape: optional, a tuple of nonnegative integers representing the result shape. Must be broadcast-compatible with ``p.shape``. The default (None) produces a result shape equal to ``p.shape``. mode: optional, "high" or "low" for how many bits to use when sampling. default='low'. Set to "high" for correct sampling at small values of `p`. When sampling in float32, bernoulli samples with mode='low' produce incorrect results for p < ~1E-7. mode="high" approximately doubles the cost of sampling. Returns: A random array with boolean dtype and shape given by ``shape`` if ``shape`` is not None, or else ``p.shape``. highlowz got mode=z, expected 'high' or 'low' bernoulliz=bernoulli probability `p` must have a floating dtype, got {}.)rKr<)r rrArPr!rr9r r8rJrrGrrr _bernoulli)rMrKrKr<rrr9rs r,rrs>   # #E *E  zD7"<= >> ; ,&#q&|[A, ))A,%   5"++ . IC CJJu% && q%(! 1\$4 114a 99r.)static_argnamescp|tj|}n td|tj|tj|}|dk(rBt |dg||\}}|dt j|j zz}|||z kSt ||tj||kS)Nrrr4) rJrKrrr9rr rr)rMrKrKr<r9u1u2s r,rr6s ] HHQKEeRXXa[1 ))A,% V^ S1+u+u -FB! U#))) ))B B; 3syy| ,q 00r.c td|\}}tj|tn|}tj|t j std||tj|}t|||||S)a Sample Beta random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x;a,b) \propto x^{a - 1}(1 - x)^{b - 1} on the domain :math:`0 \le x \le 1`. Args: key: a PRNG key used as the random key. a: a float or array of floats broadcast-compatible with ``shape`` representing the first parameter "alpha". b: a float or array of floats broadcast-compatible with ``shape`` representing the second parameter "beta". shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``a`` and ``b``. The default (None) produces a result shape by broadcasting ``a`` and ``b``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and shape given by ``shape`` if ``shape`` is not None, or else by broadcasting ``a`` and ``b``. betaz4dtype argument to `beta` must be a float dtype, got ) rPr rrr8rJrrAr r_beta)rMrIrrKr9rs r,rrHs< 63 '&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E sAq% ''r.c|=tjtj|tj|}n4t d|tj|tj|t d|||\}\}}tj ||}tj ||}t|\}}tj||}tj||}t||||}t||||}tj||} tj|| z } tj|| z } | | | zz S)Nrzjax.random.beta) rrrJrKrrandom_insert_pvaryrrr broadcast_tologgammarexp) rMrIrrKr9key_akey_b log_gamma_a log_gamma_blog_maxgamma_a_scaledgamma_b_scaleds r,rrqs ]  !bhhqk :E RXXa[9#$5sAqA+#v1 q%(! q%(!,% q% ! q% !5%0+5%0+ GGK -'77;01.77;01. >N: ;;r.ctd|\}}tj|tn|}tj|t j std|tj|}t|||S)aKSample Cauchy random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x) \propto \frac{1}{x^2 + 1} on the domain :math:`-\infty < x < \infty` Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified shape and dtype. cauchyz6dtype argument to `cauchy` must be a float dtype, got ) rPr rrr8rJrrAr r_cauchyrMrKr9rs r,rrs|, 8S )&#q  2 2}e% )%   5"++ . ##('+ ,,  ! !% (% eU ##r.c ^td|t|||tj|jd}t j |tj}t jt j|t j|t j |dS)Nrrr?) rrr repsrrrJpitanrsub)rMrKr9rkrs r,rrsqx c5% U(;(?(?K! zz!RUU" SWWQ 1c(:;< ==r.ctd|\}}tj|tn|}tj|t j std||tj|}t||||S)aSample Dirichlet random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(\{x_i\}; \{\alpha_i\}) \propto \prod_{i=1}^k x_i^{\alpha_i - 1} Where :math:`k` is the dimension, and :math:`\{x_i\}` satisfies .. math:: \sum_{i=1}^k x_i = 1 and :math:`0 \le x_i \le 1` for all :math:`x_i`. Args: key: a PRNG key used as the random key. alpha: an array of shape ``(..., n)`` used as the concentration parameter of the random variables. shape: optional, a tuple of nonnegative integers specifying the result batch shape; that is, the prefix of the result shape excluding the last element of value ``n``. Must be broadcast-compatible with ``alpha.shape[:-1]``. The default (None) produces a result shape equal to ``alpha.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and shape given by ``shape + (alpha.shape[-1],)`` if ``shape`` is not None, or else ``alpha.shape``. dirichletz9dtype argument to `dirichlet` must be a float dtype, got ) rPr rrr8rJrrAr r _dirichlet)rMalpharKr9rs r,rrsF ; ,&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E Cu --r.)r4rcddlm}tj|dk\s/d}t |j tj||tj |dd}n#td|tj |ddtj||}t|||tj |ddz|}||dS)Nr)softmaxrz8dirichlet requires alpha.ndim >= 1, got alpha.ndim == {}r?r) jax._src.nn.functionsrrJrIrArrKrrrr)rMrrKr9rrlog_gamma_sampless r,rrs+ 1  DC SZZ/ 00 ] HHUOCR EeRXXe_Sb%9: " "5% 0%sE5288E?233G+GO "B ''r.ctd|\}}tj|tn|}tj|t j std|tj|}t|||S)a<Sample Exponential random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x) = e^{-x} on the domain :math:`0 \le x < \infty`. Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified shape and dtype. exponentialz;dtype argument to `exponential` must be a float dtype, got ) rPr rrr8rJrrAr r _exponentialrs r,rrs|, =# .&#q  2 2}e% )%   5"++ . ##('+ ,,  ! !% (% c5% ((r.ctd|t|||}tjtjtj|S)Nr)rrrneglog1prMrKr9rks r,rrs:}e$ c5% ! 3771:& ''r.c 6tj|dtj|dtj|d}tj|dtj|dtj|d}tj|dtj|tjt tj |jtjt tj |jtjt tj |jtj|t tj |j}tj|}|}tj||tj|}tj||tj|tjfd}fd }t|\}} tj ||||f\} } } } |rtj"t%| d  } tj|| dk(ztj&| tj|} tjtjtj(tj(| | Sdt+| d  z }tj|tj,|tj|}tj&tj&| |S) Nrrr4r?rgUUUUUU?gm{?c|\}}}}tjtj|tjtj tj||tjtj |tj tj|tjtj tj|tj |}|Sr()r bitwise_andgerrr4r) kXVUrXVUconddone one_over_two squeeze_consts r,_cond_fnz_gamma_one.._cond_fn8sJAq!Q ?? q#''#sww}cggamDEF swwqz3773771l#;#&771cggcggc1o69ggaj/B$CD E FD Kr.c& fd}|d}t|d\}}}tjfd|| f\}}}tj||}tjtj|||} t |d } ||| | fS)Nc|d}t|\}}t|d}tjtj|}|||fS)Nrrzr)rrUrrr)kxvrMr:r+rcr9rs r, _next_kxvz/_gamma_one.._body_fn.._next_kxvEsM Fc3Kkc6 5 )a ''#swwq!} %a !QYr.rrc6tj|dS)Nr4)rle)rzeros r,rz._gamma_one.._body_fn..NscffSVT6Jr.rzr)rlax_control_flow while_looprrr)rrrMx_keyU_keyrr+rrrrrr9 minus_onerrs r,_body_fnz_gamma_one.._body_fnDs q'CsAC))*J*3eT95MOGAq! 1 A 1 q!Ar'A 1a<r.rzr)rrr9r pvaryrtypeofvmarrrrdivrZrrrrrrr4rpow)rMr log_spacetwoone_over_three boost_mask alpha_origrrr:rr log_samples log_boostsamplesboostrrr9rrrrrs @@@@@@@@r, _gamma_oners E1 $ 5!# 5!#jj#)E3',::eW-.**UF+- ))E % D% E 2 6 67 8$ 3dkk%04456#jjE$++e*<*@*@$AB) 3dkk%04456#vveS!** **Zs(; <% gge^$! ggnchhqk*! $s +#v**3c3/1*!Q1''+fb>?K :)9:D77;Z0HIKI 773773771:swwqz2I >>'&"E22G JJz3wwwZ(@A CE 773771a=% ((r.ctj|d}tj|d}|rtj|}tj|d}tj |t j|jj}tjtj||||}dntjtjj dk(rt#j$fd||f}nt'||}|jt)j*|S)Nr?rc4tj|||z Sr()rgrandom_gamma_grad)rsamples r,rz_gamma_grad..ps%%eV4v=r.cpuc|Sr(rz)args gamma_grads r,rz_gamma_grad..us j$.?r.)rrrrrrr rr9tinyreqrgrr get_backendplatformrmaprrJrK) rrIrralphasrrgradsrs @r, _gamma_gradres KK #' ;;q" &gggG ::fa D ==&,,w}}"="B"B CDjj.g>G?J..J&&%/  !?&'AR SE D VW -E rxx{ ##r.)use_vmapctj|}tj||jd}|j }t td||}|j }|j }|r=t|tjur"t tt||}ntjfd||f}tj ||S)N)rN)in_axesrct|diS)Nr)r)rrs r,rz_gamma_impl..sZ;;r.)rJrKrArBrIflattenrrrrthreefry_prng_implrrrrrr) rMrIrra_shape split_countrrrs ` r, _gamma_implrzs HHQK' '#((),-+ $ (fi ({ ;$ $ 99;& )C.D$;$;;.s'MQamaggajMs !!rr)nextzipr bdim_at_frontrandom_gamma_pbind) batched_args batch_dimsrr@rIbkbar1s r,_gamma_batching_rulersz $!Q &"b M z:M M$QD)!QD)!   QY  7 ::r. random_gammac 4tjd|||S)Nr)r standard_vma_rule)rMrIrs r,_random_gamma_abstract_evalrsa0 (r.c "|t||fi|zSr()r)tangentansrMrIkwdss r,rrs;sA3N3N)Nr.)multiple_resultsr)rc td|\}}tj|tn|}tj|t j std||tj|}t||||S)aSample Gamma random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x;a) \propto x^{a - 1} e^{-x} on the domain :math:`0 \le x < \infty`, with :math:`a > 0`. This is the standard gamma density, with a unit scale/rate parameter. Dividing the sample output by the rate is equivalent to sampling from *gamma(a, rate)*, and multiplying the sample output by the scale is equivalent to sampling from *gamma(a, scale)*. Args: key: a PRNG key used as the random key. a: a float or array of floats broadcast-compatible with ``shape`` representing the parameter of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``a``. The default (None) produces a result shape equal to ``a.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``a.shape``. See Also: loggamma : sample gamma values in log-space, which can provide improved accuracy for small values of ``a``. gamma5dtype argument to `gamma` must be a float dtype, got r rPr rrr8rJrrAr r_gammarMrIrKr9rs r,rrsH 7C (&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E Qe5 11r.c td|\}}tj|tn|}tj|t j std||tj|}t||||dS)aVSample log-gamma random values with given shape and float dtype. This function is implemented such that the following will hold for a dtype-appropriate tolerance:: np.testing.assert_allclose(jnp.exp(loggamma(*args)), gamma(*args), rtol=rtol) The benefit of log-gamma is that for samples very close to zero (which occur frequently when `a << 1`) sampling in log space provides better precision. Args: key: a PRNG key used as the random key. a: a float or array of floats broadcast-compatible with ``shape`` representing the parameter of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``a``. The default (None) produces a result shape equal to ``a.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``a.shape``. See Also: gamma : standard gamma sampler. rrTrKr9rrrs r,rrs> :s +&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E Qe5D AAr.r!cN|tj|}n td|tj|tj||}tj||k7rt j ||}td||\}\}tj|||S)Nrr) rJrKrrrrrrr r )rMrIrKr9rs r,rrs ] HHQKE%!- q%(!XXa[E E"A!'32)#t   S!y  99r.)r4rrcfd}fd}tjd|}tjdtj}t j ||d|||fd} | dz j |S)Nc|\}}}}t|\}}tj| kD|dz|}t|tj }|dz|||t j|zfSNr)rrrrrJfloat32rr4) carryrr@rnglog_prodr:rklamrKs r,body_fnz_poisson_knuth..body_fnslAq#x+KC 8sd?AE1-Arzz*A q5!S(SWWQZ/ //r.cL|d|d}}| kDj|kzS)Nrrany)r'rr)r* max_iterss r,cond_fnz_poisson_knuth..cond_fns2(E!HxA tO "a)m 44r.rr)rrrJr&rrr) rMr*rKr9r/r+r0k_init log_rate_initr@s `` ` r,_poisson_knuthr3sq 05 ==a .&--Q E:-!!'7Q]4STUVW! a% r.c tj ddtjzz dd zz dd dz z z dd d z z z   fd }fd }tjd j}tjdt jd}t j||d|||fd} | j|S)Ngn?= ףp=@gh|?5g[ m?g$~?gr?g333333 @gr鷯?gB>٬ @r4c(|\}}}}t|d\}}}t|jdz }t|j}dt|z } t j dz| z z|zzdz} t j |z| | zz zz }  | zztj| dzz } | dk\|kz} | dk| dk|| kDzz}| | k}| ||zz}t j|| |}||z}|dz|||fS) Nrrr4gQ?rQ?rg9v?) rrr9absrfloorr4rglgammar)r'rk_outacceptedrMsubkey_0subkey_1rkr u_shiftedr@rraccept1rejectaccept2acceptrIr inv_alphar*log_lamrKv_rs r,r+z#_poisson_rejection..body_fn0sF#Auh$S!nC8%+c1A%+Ac!f I 1q59$q(A-3d:;A I i)&;!F1fG ') *F JJvq% (E H q5%3 &&r.c@|\}}}}|j|kzSr(r-)r'rr;r<rMr/s r,r0z#_poisson_rejection..cond_fnFs)#Auh I?? I ..r.r?Frsrr) rr4rZrr9rJrrr)rMr*rKr9r/r+r0r1r<r@rIrrDrErFs `` ` @@@@@r,_poisson_rejectionrH%s GGCL' dSXXc]""! w{!vS)))1q5!!#'',/ ==b#))U 3& ]]3rxx'7 ?(!!'7Q#4NOPQR! %r.c t||dkz}tj||tj|d}tj|tj|d|}|j t j |j}tj|t|||||t|||||}tj|dk(tj||S)N regj@r) r-rrrrHr rrr3rHr zeros_like) rMr*rKr9 use_knuth lam_knuth lam_rejectionr/rOs r,_poissonrOPsSkS2X&)jjCsC)@A)**Y c3(?E-jje,001) :: 3 5%;sM5%C & C1HcnnV4f ==r.ctd|\}}tj|tn|}t j t j|j}|j}|t jurtd||tj|}ntj|}t!j"||}t%j&|tj(}t+||||S)a\Sample Poisson random values with given shape and integer dtype. The values are distributed according to the probability mass function: .. math:: f(k; \lambda) = \frac{\lambda^k e^{-\lambda}}{k!} Where `k` is a non-negative integer and :math:`\lambda > 0`. Args: key: a PRNG key used as the random key. lam: rate parameter (mean of the distribution), must be >= 0. Must be broadcast-compatible with ``shape`` shape: optional, a tuple of nonnegative integers representing the result shape. Default (None) produces a result shape equal to ``lam.shape``. dtype: optional, a integer dtype for the returned values (default int64 if jax_enable_x64 is true, otherwise int32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape is not None, or else by ``lam.shape``. poissonz<`poisson` is only implemented for the threefry2x32 RNG, not )rPr rrrrrrrr9r_rr2r rrJrKrrrrr&rO)rMr*rKr9rrrs r,rQrQes2 9c *&#q  2 2 ]c '%{{4::syy1*   ( T,,,  j     # #E *E HHSME e$#   bjj1# #sE5 ))r.ctd|\}}tj|tn|}tj|t j std|tj|}|tjjrdnd}|dvrtd|zt|d|}tt|||||S)aSample Gumbel random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x) = e^{-(x + e^{-x})} Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). mode: optional, "high" or "low" for how many bits to use when sampling. The default is determined by the ``use_high_dynamic_range_gumbel`` config, which defaults to "low". When drawing float32 samples, with mode="low" the uniform resolution is such that the largest possible gumbel logit is ~16; with mode="high" this is increased to ~32, at approximately double the computational cost. Returns: A random array with the specified shape and dtype. rGz6dtype argument to `gumbel` must be a float dtype, got rrrz*Must provide valid mode for gumbel got: %s)rKr9r<)rPr rrr8rJrrAr rr use_high_dynamic_range_gumbelr>rr_gumbel)rMrKr9r<rrs r,rGrGs: 8S )&#q  2 2}e% )%   5"++ . ##('+ ,,  ! !% (% \99??6UD  ADH II3L(ER, $,e5" $$' ))r.)rr4rc td|tj|}|dk(r|t|ddd|z|\}}t j |dk\||d|j z|zz|jz}t jt j|   St jt jt||jd||  S) NrGrrerr.)rrrKr9rr4) rr rrrwhererrr4r)rMrKr9r<r rrr+s r,rTrTsx e $ V^R#e|5:ID# $#+t qdjjM!C''$))3 5A GGSYYr]N # ## GGSWWTYYreLNN O OOr.c td|\}}td|tj|}t t j |j|}||}n"tj|}td|||dt|t|z } |r|dk\r|t|jz}t|t|t|z d} | j|t|jz|j|tjt|g| | |j |t#j$|t t't| z|S|t||j|j |z }t)j*| } | |j|kDrt-d| d|j|dt#j.tj0||d | \}} | j|| fzk(sJ|| |zk(sJ| j2d z gt'| j2d z } t#j4| || } | j|k(sJ| S) aSample random values from categorical distributions. Sampling with replacement uses the Gumbel max trick. Sampling without replacement uses the Gumbel top-k trick. See [1] for reference. Args: key: a PRNG key used as the random key. logits: Unnormalized log probabilities of the categorical distribution(s) to sample from, so that `softmax(logits, axis)` gives the corresponding probabilities. axis: Axis along which logits belong to the same categorical distribution. shape: Optional, a tuple of nonnegative integers representing the result shape. Must be broadcast-compatible with ``np.delete(logits.shape, axis)``. The default (None) produces a result shape equal to ``np.delete(logits.shape, axis)``. replace: If True (default), perform sampling with replacement. If False, perform sampling without replacement. mode: optional, "high" or "low" for how many bits to use in the gumbel sampler. The default is determined by the ``use_high_dynamic_range_gumbel`` config, which defaults to "low". With mode="low", in float32 sampling will be biased for events with probability less than about 1E-7; with mode="high" this limit is pushed down to about 1E-14. mode="high" approximately doubles the cost of sampling. Returns: A random array with int dtype and shape given by ``shape`` if ``shape`` is not None, or else ``np.delete(logits.shape, axis)``. References: .. [1] Wouter Kool, Herke van Hoof, Max Welling. "Stochastic Beams and Where to Find Them: The Gumbel-Top-k Trick for Sampling Sequences Without Replacement". Proceedings of the 36th International Conference on Machine Learning, PMLR 97:3499-3508, 2019. https://proceedings.mlr.press/v97/kool19a.html. categoricalNr)r<r%z'Number of samples without replacement (z&) cannot exceed number of categories (z).r?r)rPrrrrrJdeleterKr rrrlistinsertargmaxrGr9r expand_dimsr5rArBrArHmoveaxisrIr)rMlogitsr%rKrJr<r logits_arr batch_shape shape_prefix logits_shaper@indices dimensionss r,rXrXsZP =# .&#q-({{6"*bii 0 0$78+ ] E  # #E *E{33E 3{#334,  qy c*""##dc%j3{+;;<=>Ls:#3#344j6F6Ft6LM ::s2l2\2J4D4D4P  E%L0A*B$CD E   &j.. 0@0@tLLJ ,A:  D !!  1!5!''-.b 2  3<< D"=qAJAw ==K1$. .. . L;. .. .,,"=U7<td|t|||dtj|jzd}t j t j|t jt jt j|S)Nrhrdrr) rrr repsnegrrsignrrr8rs r,riri<siy%   5%fll5&9&@&@ @M! !cii (;< ==r.ctd|\}}tj|tn|}tj|t j std|tj|}t|||S)a%Sample logistic random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x) = \frac{e^{-x}}{(1 + e^{-x})^2} Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified shape and dtype. logisticz8dtype argument to `logistic` must be a float dtype, got ) rPr rrr8rJrrAr r _logisticrs r,rnrnDs|( :s +&#q  2 2}e% )%   5"++ . ##('+ ,,  ! !% (% 3u %%r.ctd|t|||tj|jd}t j t j|t jt j|S)Nrnrr) rrr rrrrr4rr)rMrKr9r+s r,roroasWz5! c5% U(;(@(@L! SYYswwqz2 33r.ctd|\}}tj|tn|}tj|t j std||tj|}t||||S)a~Sample Pareto random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x; b) = b / x^{b + 1} on the domain :math:`1 \le x < \infty` with :math:`b > 0` Args: key: a PRNG key used as the random key. b: a float or array of floats broadcast-compatible with ``shape`` representing the parameter of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``b``. The default (None) produces a result shape equal to ``b.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``b.shape``. paretoz6dtype argument to `pareto` must be a float dtype, got ) rPr rrr8rJrrAr r_pareto)rMrrKr9rs r,rrrrhs6 8S )&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E a &&r.c|tj|}n td|tj||}t |||}tj ||z S)Nrr)rJrKrrrrr)rMrrKr9es r,rsrssP ] HHQKE5! q%(!#ue$! Qr.ctd|\}}tj|tn|}tj|t j std|tj|}t||||S)aSample Student's t random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(t; \nu) \propto \left(1 + \frac{t^2}{\nu}\right)^{-(\nu + 1)/2} Where :math:`\nu > 0` is the degrees of freedom, given by the parameter ``df``. Args: key: a PRNG key used as the random key. df: a float or array of floats broadcast-compatible with ``shape`` representing the degrees of freedom parameter of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``df``. The default (None) produces a result shape equal to ``df.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``df.shape``. rz1dtype argument to `t` must be a float dtype, got ) rPr rrr8rJrrAr r_trMdfrKr9rs r,rrs~6 3 $&#q  2 2}e% )%   5"++ . ##('+ ,,  ! !% (% CUE ""r.c~|tj|}n td|tj|tj||}t |\}}t |||}tj|d}tj||}t||||} |tj|| z zS)Nrr4) rJrKrrrrrUrrrrrZ) rMryrKr9key_nkey_grxrhalf_dfrSs r,rwrws ] HHRLEeRXXb\* E*",% UE5!! 1a# GGB ' E7E5)! SXXgk " ""r.ctd|\}}tj|tn|}tj|t j std||tj|}t||||S)aSample Chisquare random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x; \nu) \propto x^{\nu/2 - 1}e^{-x/2} on the domain :math:`0 < x < \infty`, where :math:`\nu > 0` represents the degrees of freedom, given by the parameter ``df``. Args: key: a PRNG key used as the random key. df: a float or array of floats broadcast-compatible with ``shape`` representing the parameter of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``df``. The default (None) produces a result shape equal to ``df.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``df.shape``. chisquarez9dtype argument to `chisquare` must be a float dtype, got ) rPr rrr8rJrrAr r _chisquarerxs r,rrs8 ; ,&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E CUE **r.cj|tj|}n td|tj|tj||}tj |d}tj ||}t||||}tjtj||}|S)Nrr4)rIrKr9) rJrKrrrrrrrrr)rMryrKr9rr}log_gchi2s r,rrs ] HHRLEeRXXb\2 E*" 2q# GGB ' 3'e <%  %$ +r.c td|\}}tj|tn|}tj|t j std||tj|}t|||||S)a-Sample F-distribution random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x; \nu_1, \nu_2) \propto x^{\nu_1/2 - 1}\left(1 + \frac{\nu_1}{\nu_2}x\right)^{ -(\nu_1 + \nu_2) / 2} on the domain :math:`0 < x < \infty`. Here :math:`\nu_1` is the degrees of freedom of the numerator (``dfnum``), and :math:`\nu_2` is the degrees of freedom of the denominator (``dfden``). Args: key: a PRNG key used as the random key. dfnum: a float or array of floats broadcast-compatible with ``shape`` representing the numerator's ``df`` of the distribution. dfden: a float or array of floats broadcast-compatible with ``shape`` representing the denominator's ``df`` of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``dfnum`` and ``dfden``. The default (None) produces a result shape equal to ``dfnum.shape``, and ``dfden.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``df.shape``. rz1dtype argument to `f` must be a float dtype, got ) rPr rrr8rJrrAr r_f)rMdfnumdfdenrKr9rs r,rrsD 3 $&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E Cue ,,r.ct|=tjtj|tj|}n4t d|tj|tj|tj ||}tj ||}t |\}}t||||}t||||}tj||}tj||}tj||} tj||} tj| | } | S)Nr) rrrJrKrrrrrrr) rMrrrKr9key_dfdkey_dfnchi2_dfnchi2_dfdrdenrs r,rr-s ]  ! !"((5/288E? CEeRXXe_bhhuo> " "5% 0% " "5% 0%C['7 wue 4( wue 4(  5% (%  5% (% % # % # ggc3! (r.ctd|\}}tj|tn|}t j |}t |||S)aSample from a Rademacher distribution. The values are distributed according to the probability mass function: .. math:: f(k) = \frac{1}{2}(\delta(k - 1) + \delta(k + 1)) on the domain :math:`k \in \{-1, 1\}`, where :math:`\delta(x)` is the dirac delta function. Args: key: a PRNG key. shape: The shape of the returned samples. Default (). dtype: The type used for samples. Returns: A jnp.array of samples, of shape `shape`. Each element in the output has a 50% change of being 1 or -1. rademacher)rPr rrrr r _rademacherrs r,rrAsL, < -&#q  2 2 ]c '%  ! !% (% S% ''r.cjt|d|j|}d|zdz j|S)Nr)rMrKrKr4r)rr)rMrKr9bernoulli_sampless r,rr^s8C3e<CCEJ  ! # + +E 22r.ctd|\}}tj|tn|}tj|t j std|tj|}t|||S)aSample from a one sided Maxwell distribution. The values are distributed according to the probability density function: .. math:: f(x) \propto x^2 e^{-x^2 / 2} on the domain :math:`0 \le x < \infty`. Args: key: a PRNG key. shape: The shape of the returned samples. dtype: The type used for samples. Returns: A jnp.array of samples, of shape `shape`. maxwellz7dtype argument to `maxwell` must be a float dtype, got ) rPr rrr8rJrrAr r_maxwellrs r,rrds|. 9c *&#q  2 2}e% )%   5"++ . ##('+ ,,  ! !% (% #ue $$r.cV|dz}t|||}tj|dS)N)r)rMrKr9r?rY)rUrznorm)rMrKr9norm_rvss r,rrs* $,% 5 6(  ++r.ctd|\}}tj|tn|}tj|t j std|tj|}t|||||S)arSample from a double sided Maxwell distribution. The values are distributed according to the probability density function: .. math:: f(x;\mu,\sigma) \propto z^2 e^{-z^2 / 2} where :math:`z = (x - \mu) / \sigma`, with the center :math:`\mu` specified by ``loc`` and the scale :math:`\sigma` specified by ``scale``. Args: key: a PRNG key. loc: The location parameter of the distribution. scale: The scale parameter of the distribution. shape: The shape added to the parameters loc and scale broadcastable shape. dtype: The type used for samples. Returns: A jnp.array of samples. double_sided_maxwellzDdtype argument to `double_sided_maxwell` must be a float dtype, got ) rPr rrr8rJrrAr r_double_sided_maxwell)rMlocscalerKr9rs r,rrs4 13 7&#q  2 2}e% )%   5"++ . $$)7, --  ! !% (% sCu ==r.c,tjtj|tj|}|s|}||z}t |\}}t |||}t |||} | j|jk(sJ| |z|z|zS)Nr)rrrJrKrrr) rMrrrKr9 params_shapes maxwell_keyrademacher_key maxwell_rvs random_signs r,rrs&&rxx}bhhuoF-  E - % &s +~ 5>+>eD+   k// // / { "U *S 00r.ctd|\}}tj|tn|}tj|t j std|tj|}t|||||S)a~Sample from a Weibull distribution. The values are distributed according to the probability density function: .. math:: f(x;\sigma,c) \propto x^{c - 1} \exp(-(x / \sigma)^c) on the domain :math:`0 < x < \infty`, where :math:`c > 0` is the concentration parameter, and :math:`\sigma > 0` is the scale parameter. Args: key: a PRNG key. scale: The scale parameter of the distribution. concentration: The concentration parameter of the distribution. shape: The shape added to the parameters loc and scale broadcastable shape. dtype: The type used for samples. Returns: A jnp.array of samples. weibull_minz;dtype argument to `weibull_min` must be a float dtype, got ) rPr rrr8rJrrAr r _weibull_min)rMr concentrationrKr9rs r,rrs4 =# .&#q  2 2}e% )%   5"++ . ##('+ ,,  ! !% (% c5- >>r.ct||dd|}tjtj|  d|z |zS)Nrr)rMrKrrr9r)rrpowerr)rMrrrKr9random_uniforms r,rrsB U1Qe=. CII~o..M0A BU JJr.c>||}n|}tj|}td|\}}tj|t n|}t d|tjt|d}tjt|d}t|g|t||t|||}tj|\}} tj| } |tj tj"| dz} ||kr | j$S| S)aSample uniformly from the orthogonal group O(n). If the dtype is complex, sample uniformly from the unitary group U(n). For unequal rows and columns, this samples a semi-orthogonal matrix instead. That is, if :math:`A` is the resulting matrix and :math:`A^*` is its conjugate transpose, then: - If :math:`n \leq m`, the rows are mutually orthonormal: :math:`A A^* = I_n`. - If :math:`m \leq n`, the columns are mutually orthonormal: :math:`A^* A = I_m`. Args: key: a PRNG key used as the random key. n: an integer indicating the number of rows. shape: optional, the batch dimensions of the result. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). m: an integer indicating the number of columns. Defaults to `n`. Returns: A random array of shape `(*shape, n, m)` and specified dtype. References: .. [1] Mezzadri, Francesco. (2007). "How to generate random matrices from the classical compact groups". Notices of the American Mathematical Society, 54(5), 592-604. https://arxiv.org/abs/math-ph/0609050. orthogonalz-The error occurred in jax.random.orthogonal()rw)r rrPr rrrr(rrUrrrzqrdiagonalrr^rlmT) rMrxrKr9m_mrzqr&rr+s r,rrsDY B B  ! !% (% < -&#q  2 2}e% )%|U# UA'VW! eR)XY" S2E23q":2s1bz2E:! q $!Q!!#//#((1+r **!V 44K Hr.ctj|}td|\}}tj|t n|}t d|t|}t|dd|z ||}t|d||}||d|z zzS)auSample from the generalized normal distribution. The values are returned according to the probability density function: .. math:: f(x;p) \propto e^{-|x|^p} on the domain :math:`-\infty < x < \infty`, where :math:`p > 0` is the shape parameter. Args: key: a PRNG key used as the random key. p: a float representing the shape parameter. shape: optional, the batch dimensions of the result. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified shape and dtype. generalized_normalrr) r rrPr rrrrrr)rMrKrKr9rrrSr&s r,rr% s4  ! !% (% / 5&#q  2 2}e% )%#U+ s$ DGQqS%'!a%'! Q1q5\ r.ctj|}td|\}}tj|t n|}t d|tjt|d}t|\}}t||g|||}t|||} |tj||zjd| zd|z zdz S)a$Sample uniformly from the unit Lp ball. Reference: https://arxiv.org/abs/math/0503650. Args: key: a PRNG key used as the random key. d: a nonnegative int representing the dimensionality of the ball. p: a float representing the p parameter of the Lp norm. shape: optional, the batch dimensions of the result. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array of shape `(*shape, d)` and specified dtype. ballz'The error occurred in jax.random.ball()r?r).N)r rrPr rrrr(rrrrrr8sum) rMrrKrKr9rrrrSrus r,rrI s,  ! !% (% 63 '&#q  2 2}e% )%vu UA'PQ! :&"bQ %  U3!"eU#!  a$$R(1,!a%8) D DDr.ctd|\}}tj|tn|}tj|t j std||tj|}t||||S)aSample Rayleigh random values with given shape and float dtype. The values are returned according to the probability density function: .. math:: f(x;\sigma) \propto xe^{-x^2/(2\sigma^2)} on the domain :math:`-\infty < x < \infty`, and where :math:`\sigma > 0` is the scale parameter of the distribution. Args: key: a PRNG key used as the random key. scale: a float or array of floats broadcast-compatible with ``shape`` representing the parameter of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``scale``. The default (None) produces a result shape equal to ``scale.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``scale.shape``. rayleighz8dtype argument to `rayleigh` must be a float dtype, got ) rPr rrr8rJrrAr r _rayleigh)rMrrKr9rs r,rrk s8 :s +&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E 3ue ,,r.c|tj|}n td|tj|t|||}|j |}t j ||}tj|}tj|d}tjtj||}tj||}|S)Nrrw) rJrKrrrrrrr4rrZr) rMrrKr9rklog_un_twosqrt_urays r,rr s ] HHUOEUBHHUO4 c5% ! ,,u %  5% (% ''!*% **UB % 88CGGE5) *& v# *r.ctd|\}}tj|tn|}tj|t j std||tj|}t||||S)aSample Wald random values with given shape and float dtype. The values are returned according to the probability density function: .. math:: f(x;\mu) = \frac{1}{\sqrt{2\pi x^3}} \exp\left(-\frac{(x - \mu)^2}{2\mu^2 x}\right) on the domain :math:`-\infty < x < \infty`, and where :math:`\mu > 0` is the location parameter of the distribution. Args: key: a PRNG key used as the random key. mean: a float or array of floats broadcast-compatible with ``shape`` representing the mean parameter of the distribution. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``mean``. The default (None) produces a result shape equal to ``np.shape(mean)``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``mean.shape``. waldz4dtype argument to `wald` must be a float dtype, got ) rPr rrr8rJrrAr r_wald)rMrrrKr9rs r,rr s: 63 '&#q  2 2}e% )%   5"++ . ##('+ ,,   # #E *E sD% ''r.cl|tj|}n td|tj|t|d\}}|j |}t j ||}t|||}t|||}tj|d}tj|d} tj|d} tjd|z|z| | zz} || |zdz z|dz | zz } tjtj|||| zz | | | z } | S)Nrr4r)rJrKrrrrrrUrr integer_powrZrr)rMrrrKr9rrrryy_sqmean_sq sqrt_termr+r~s r,rr s ] XXd^E/ #q>&"b U $  $ &$ R! b%! ooa! A $ OOD! $'hhq4x!|gn45) Wq[1_tax)33! jjDD1H-.7Q;?! (r.ctd|\}}tj|tn|}tj|t j std||tj|}t||||S)aoSample Geometric random values with given shape and float dtype. The values are returned according to the probability mass function: .. math:: f(k;p) = p(1-p)^{k-1} on the domain :math:`0 < p < 1`. Args: key: a PRNG key used as the random key. p: a float or array of floats broadcast-compatible with ``shape`` representing the probability of success of an individual trial. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``p``. The default (None) produces a result shape equal to ``np.shape(p)``. dtype: optional, a int dtype for the returned values (default int64 if jax_enable_x64 is true, otherwise int32). Returns: A random array with the specified dtype and with shape given by ``shape`` if ``shape`` is not None, or else by ``p.shape``. geometricz8dtype argument to `geometric` must be an int dtype, got ) rPr rrrr8rJrrAr r _geometric)rMrKrKr9rs r,rr s6 ; ,&#q  2 2 ]c '%   5"** - ##('+ ,,   # #E *E CE5 ))r.c|tj|}n td|tj|td|t |\}t |||j }tj|}tj| }tj||}tjtj||dz}|j|S)Nrr)rJrKrrrrr9rr4rrrr9rr)rMrKrKr9rkrlog_one_minus_prSs r,rr s ] XXa[EeRXXa[1+q!a "! c5!''"! ''!*%IIqbM/$$_e 0`. Args: key: a PRNG key used as the random key. sigma: a float or array of floats broadcast-compatible with ``shape`` representing the standard deviation of the underlying normal distribution. Default 1. shape: optional, a tuple of nonnegative integers specifying the result shape. The default (None) produces a result shape equal to ``()``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape``. lognormalzDdtype argument to `lognormal` must be a float or complex dtype, got ) rPr rrr8rJrVrAr r _lognormal)rMsigmarKr9rs r,rrO s2 ; ,&#q  2 2}e% )%   5"** - !7$ %%   # #E *E Cu --r.c|tj|}n td|tj|tj||}t ||||z}t j|S)Nr)rJrKrrrrUrr)rMrrKr9 scaled_norms r,rrr s\ ] XXe_Eubhhuo6  5% (%sE5)E1+  r.ctjgd|j}|dk}tjtj |d|tj |d}|dz|dzz}ddd |z z |z z |dzz }tj |}tj||tj|d |S) N) gW ڼq?g;>*?g&W?gxb&J?g?QN ?g{k?g^J.aM]?g?0{^R?gb?gCL?r reg"@rgUUUUUU?gllf?gJ?r) rrr9rclamprr9rr)r@stirling_tail_valsuse_tail_valueskp1sqapproxs r,_stirling_approx_tailr} syy  GGF/ ii 1c"Aszz!S'9:! q5QU %  J$66%? ?AE J& iil! )#++aw*GH& RRr.c tjjr0tjj t jsJtj   fd}fd}tjdj }tjdj } d|| |f} tj||| d} | dz j|S)Nc|\}}}}t|\}}tj| k|dz|}t| j}t j t j| z }||z}|dz|||fSr%)rrrrr9rr3r4) r'rnum_geomgeom_sumrMr: num_geom_outrkgeomcount log1minusprobprobrKs r,r+z$_binomial_inversion..body_fn s!&Ax3*KFC::h%/AxHLtzz*A 88CGGAJ. /D$H q5,# --r.cJ|d|d}}|kj|kzSNrr4r-)r'rrrr/s r,r0z$_binomial_inversion..cond_fn s1(E!HxA   " " $I 66r.rr)r enable_checksr>r r8r9rJrrrrrrrr) rMrrrKr9r/r+r0 num_geom_init geom_sum_initr'r@rs ``` ` @r,_binomial_inversionr s    TZZ 55 5))TE"-.7--aU;---aU;- m]C 0%!!'7E:1=! a% r.c  tjzdz z}dd|zz dd zzdzz zdzdd z z dz z d d z z|z tjdzz f d }fd }tjdj } d| tj dt|f} tj||| dj|S)Nrgffffff?r5gEJYga+e?{Gz?rgq= ףp?g@gp= ף@gffffff@cV |\}}}}t|d\}}}t|j}t|j}|dz }dtj|z } | dk\|kz} tj dz| z z|zz} | dk| kDz} tj |z| | zz zz }dztj dzz dzzz zdztj z dz| z dzz zz| dztj | z dzz| dzz zztztz zt| z t| z z } || k}| | |zz}tj|| |}||z}|dz|||fS)Nrrr7r4rr) rrr9rr8r9r4rrr)r'rr;r<rMr=r>rkrusr@r@rAubrBrCrIrrrrrrr&rKrFs r,r+z_btrs..body_fn s#Auh#CmC8%,A%,A CA swwqz BTza3h'G 1q52:>Q&*+A!eE "F E Q"r']Q./0A3w#''1q5Q%!)a-%89:: cgguqy1}Q?@@A SCGGAQ/1q59::; a ! eai( ) a ! eai( )2gG ') *F JJvq% (E H q5%3 &&r.cF|d|d}}|j|kzSrr-)r'rr<r/s r,r0z_btrs..cond_fn s,(E!HxA I?? I ..r.r?rF) rrZr9rrr9fullrsrrr)rMrrrKr9r/stddevr+r0r1r'rIrrrrr&rFs ``` ` @@@@@@@r,_btrsr s 88EDLAH- .& TF]!  TD[(! dlS! sQw# a$h! #'>V #% iid"#!''4/ ==r4::u 5& fchhueT2C 8%  $ $Wgu =a @ G G NNr.c  |=tjtj|tj|}n4t d|tj|tj|t |\}t j||j}tj||}tj||}|dk}t j||d|z }t||dkz}tj|}t|} |dk} t j| | zt j|d|}|||zdkz} tj|}t j| |t j|d} t j| t j|d|} t j| t j|d|}|jt!j"|j$}t j| t'|| ||||t)|| ||||}| | z|z}t j|tj|tj*||}t j||ztj|tj,||}t j||z| z|z||j/||z }|S)Nbinomialrrrerg$@g@)rrrJrKrrrrr9rrr-isinfrr9rHr rrrrnanrr)rMrrrKr9 p_lt_halfrcount_nan_or_neg count_infq_is_nanq_l_0 use_inversion count_inv count_btrsq_btrsr/rinvalids r, _binomialr sx  ]  %"((4. AEUBHHUORXXd^D "4 ('4 " "5$** 5%  5% (%  $ &$Sj) jjD#*-!E]eck2ii) AY( c'% jjE!3==D#91=!"eai4&78- ))E %jjs}}UC/HI)zz-uc)BEJ* ::mS]]1c%:A >&jje,001) JJY5%C #z65%; 'X  0 0' JJ MM'2665)  ' JJ 'MM'2665)  ' JJ   8+i7  LL'! ' .r.c$td|\}}td||tj|tn|}tj |t jstd||tj|}t|||||S)aSample Binomial random values with given shape and float dtype. The values are returned according to the probability mass function: .. math:: f(k;n,p) = \binom{n}{k}p^k(1-p)^{n-k} on the domain :math:`0 < p < 1`, and where :math:`n` is a nonnegative integer representing the number of trials and :math:`p` is a float representing the probability of success of an individual trial. Args: key: a PRNG key used as the random key. n: a float or array of floats broadcast-compatible with ``shape`` representing the number of trials. p: a float or array of floats broadcast-compatible with ``shape`` representing the probability of success of an individual trial. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``n`` and ``p``. The default (None) produces a result shape equal to ``np.broadcast(n, p).shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``np.broadcast(n, p).shape``. rz8dtype argument to `binomial` must be a float dtype, got ) rPrr rrr8rJrrAr rr)rMrxrKrKr9rs r,rr sD :s +&#q*a#  2 2}e% )%   5"++ .  B5'J    # #E *E 31eU ++r. random_clonec|Sr(rzr*s r,rrN s1r.c|gSr(rz)rr@s r,rrP sQCr.)rKr9unrollc*td|\}}td||t||\}}| |j}t j ||dd}t j ||}d}t j |dd}tj|dd}|t j|dk(d|z } t|| jd} tj||| | f| \} } t j | ddj|S) aSample from a multinomial distribution. The probability mass function is .. math:: f(x;n,p) = \frac{n!}{x_1! \ldots x_k!} p_1^{x_1} \ldots p_k^{x_k} Args: key: PRNG key. n: number of trials. Should have shape broadcastable to ``p.shape[:-1]``. p: probability of each outcome, with outcomes along the last axis. shape: optional, a tuple of nonnegative integers specifying the result batch shape, that is, the prefix of the result shape excluding the last axis. Must be broadcast-compatible with ``p.shape[:-1]``. The default (None) produces a result shape equal to ``p.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). unroll: optional, unroll parameter passed to :func:`jax.lax.scan` inside the implementation of this function. Returns: An array of counts for each outcome with the specified dtype and with shape ``p.shape`` if ``shape`` is None, otherwise ``shape + (p.shape[-1],)``. multinomialNr?cl|\}}t|||jdd|j}||z |fS)Nrrr)rrr9) remainder ratio_keyratiorMrs r,rzmultinomial..f~ s:JE3 S)UZZ1%5Y__ ME u e ##r.rT)reverser)r) rPrrrKrrr_rrErVrscanr) rMrxrKrKr9rrrremaining_probsratiosrrcountss r,rrS sD =# .&#q-A& 1 %$!Q ] GGE q%*%! q% !$  ll1b!!$++Aq$?/ syyA-q/B B& sFLLO $$&++Aq64.P)V fa $ + +E 22r.c,tj|S)a}Clone a key for reuse Outside the context of key reuse checking (see :mod:`jax.experimental.key_reuse`) this function operates as an identity. Examples: >>> import jax >>> key = jax.random.key(0) >>> data = jax.random.uniform(key) >>> cloned_key = jax.random.clone(key) >>> same_data = jax.random.uniform(cloned_key) >>> assert data == same_data )random_clone_pr )rMs r,cloner! s   S !!r.c btjjs||fS|s||fStj|j }g}|D]}t tj|x}tjr |j n t|z r(tj|tfd|D}|tj|j k7r:t|dtj|dtj|d|j|||fS)Nc3,K|] }|vs| ywr(rz)r~r@arg_vmas r,rz&random_insert_pvary.. sEAAW4DaEs z= requires all arguments to have matching type. Got key type: z vs arg type: z. Use jax.lax.pcast(..., to='varying') to make them match. If your key is less varying than arg, watch out for key-reuse problems.) r _check_vmar>r rrr7 ShapedArray frozensetrrrGappend)rLrMrkey_vmarrIavalr$s @r,rr s    9 9 KK  ' # a%dkk!n&
N>NOtxxK  **QEEE Fa$++a.$$$  Fkk# ~dkk!n-=>F F GG JJqM c/r.)r+r#rqr")rLrirMr#r0rsrqztuple[Array, bool])rMr"rWrrrKShaperqr")rPRNGSpecDesc | Nonerqr`)rrirint | ArrayLikerr,rqr")rr-r3r,rqr")rMr#r IntegerArrayrqr")rMr"rint | tuple[int, ...]rqr")rMr#rr/rqr")rr"rqr`)rr"rqstr | PRNGSpec)rr#rqr0)rr"rqr")rr#rqr")rr"r3r,)rLrirKr+rqNone)rzN)rMr#rKr+r9zDTypeLikeUInt | Nonerqr")rzNrer) rMr#rKr+r9DTypeLikeFloat | Noner RealArrayrr3rqr")rqr")rr"r9r$rqr"r() rMr#rKr+rr.rr.r9DTypeLikeInt | Nonerqr")rF) rMr#r+r-r%rrr'rsrqr")rzTNrN)rMr#rIr-rKr+rJrsrKzRealArray | Noner%rrr< str | Nonerqr")rMr#rKr+r9r2rqr")NNrp)rMr#rrr3rsr3rK Shape | Noner9r2rtrirqr")NN) rMr#rr3rr3rKr6r9r2rqr")rNr) rMr#rKr3rKr6r<rirqr") rMr"rKr"rKr6r<rirqr") rMr#rIr3rr3rKr6r9r2rqr") rMr#rr3rKr6r9r2rqr")rMr"rqr") rMr#rIr3rKr6r9r2rqr")F) rMr#r*r3rKr6r9r4rqr")rzNN) rMr#rKr+r9r2r<r5rqr")r?NTN)rMr#r`r3r%rrrKr6rJrsr<r5rqr") rMr#rr3rKr6r9r2rqr") rMr#ryr3rKr+r9r2rqr") rMr#ryr3rKr6r9r2rqr") rMr#rr3rr3rKr6r9r2rqr")rMr#rKr+r9r4rqr") rMr#rr3rr3rKr+r9r2rqr") rMr#rr3rr3rKr+r9r2rqr") rMr#rxrrrKr+r9r2rz int | Nonerqr") rMr#rKrrKr+r9r2rqr")r4rzN) rMr#rrrrKrrKr+r9r2) rMr#rr3rKr6r9r2rqr") rMr#rrr3rKr6r9r2rqr") rMr#rKr3rKr6r9r4rqr")rMr#rr3r<r3rr3rKr6r9r2rqr") rMr#rr3rKr6r9r2rqr") rMr"rxr3rKr3rKr6r9r2rqr") rMr"rxr3rKr3rKr6r9r2rz int | bool) __future__rcollections.abcrr functoolsrrAoperatorrrrrCr rJjax._srcr r r r rrr jax._src.meshrjax._src.sharding_implsrrr jax._src.apirrjax._src.interpretersrrr jax._src.laxrrrrrgjax._src.numpyrr|rrzjax._src.numpy.utilrrr jax._src.pjitr r!jax._src.typingr"r#r$r% jax._src.utilr&r3r. DTypeLikeInt DTypeLikeUIntDTypeLikeFloatrrr+r`rr-rPrTrYr<r^ri PRNGSpecDescrrrMrrrrrrrrrrrrrrrrrrr r!r)r#r>rUrWr\rmrqrrrrrrrrrrrrrrrr Primitiver def_implrdef_abstract_evaldefjvp2register_lowering lower_funprimitive_batchersrrrr3rHrOrQrGrTrXrhrirnrorrrsrrwrrrrrrrrrrrrrrrrrrrrrrrr&rrrrrrrr  simple_impl defvectorizedrr!rrzr.r,rSs,#.  !+E"$*&9///SS#9>>+       ==  +0 #' 4F F;A"EE0S(Hh67 P. +' +,1 +%)!!!-2!*)->%>16>:-& - < B "/39+9*8;'+@ @@$@ % @@+/ " " H  HH(HH H #( HBF*?*?Z!7P*. B  BB B!B' B #( BHFLILIb$)N " N"NN"N ', N@5D  B!%" UOUOUOUO UO  UO  UO (- UOr*. O O O' O"' ODF + +FFF/37;&0 1D'1D&1D ,1D 5 1D !$ 1D 6; 1DfIF,048 +F &* +F%+F%+F)+F2 +F /4 +FZFOO0!$(+9# +9+9!+9+9(- +9\gv&'1(1( $(, &( &( &(&(& &(27 &(R<.*.$$'$38$>F>>%)-1+.+.!+.++.7<+.ZF((( "/3)),)8=)>F((L)^$*05'"; / $  !<=  DNP~~t~~ K$'(~~t~~ K$'(&+-/CN+!%)-,2 ,2,2',238,2b$(,0'B'B 'B*'B6;'BT45 :6 :I,I''TF>>,#')-******'**38**\*."*)  *)*)'*)*) "' *)XI O O& MM M M  M  M  M Mb+/%%(%49%:F>>,0&&)&5:&:F44"&*.#'#'#'(#'49#'JF%)"# "# "##"#/4"#HF # #"%)-1$+$+!$++$+7<$+LF   !%) *- *- *-*-# *-/4 *-XF  (!,0(()(5:(:F33 +/%%(%49%BF,,)+8< !>'!> )!>!&!>!6 !>BG !>HF 1 1$ "/3 !? !?(!?!?- !?9> !?HFKK!% 6 6 6  6   6  6  6 v!% "" " "  "  "N!% EEE E  E  EH$(,0$-$- $-*$-6;$-LF    $(,%(%(%(&%(27%(NF  (%)+/#*#*!#*)#*5:#*JF  &&*.2 ,;,;,; ,;# ,; , ,; 8= ,;\F4( ) $",A$(-1!.!.!!.+!.7<!.FF4()R2Id+,4Id+,O,,O^F4(7)7|#' ,, ,,,,,,  ,, ! ,,  ,,` /^$ -~&~'78#'93 939393  93 ! 93 93x"$r.