Vpf% p ddlmZddlmZmZddlmZddlZddlm Z ddl Z ddl m Z ddl Z ddl Zddlm ZddlmZddlmZmZmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZm Z ddl!m"Z"ddl!m#Z#ddl!m$Z$ddl%mZ&ddl'm(Z(ddl)m*Z*m+Z+m,Z,ddl-m.Z.m/Z/m0Z0ddl1m2Z2e/Z3e/Z4e0Z5e0Z6e0Z7ee8Z9ej:Z:e.Z;e/ZZ?ddZ@dddd%ZAd&ZBdd,ZCd-ZDGd.d/ZEe eFeEe:fZGdd3ZHdd7ZIdd8dd:ZJdd8dd;ZKdd>ZLdcddBZMdcddCZNddEZOddGZPddHZQddIZRdd8ddKZSddMZT dddQZUdNeVdRdSfddXZWeedYZdd[ZXe8fdd]ZYeed^Zdd_ZZ dddbZ[eedcZdddZ\ dddjZ]dNeVfddkZ^eedYZddlZ_eedYZddmZ` dddtZaeeduZddvZbdeVfddyZceedzZdd{Zdejed|dfdd}ZfeedcZdd~ZgdeVfddZhddZidNeVfddZjeedYZddZkdeVfddZleedZddZmddZndNeVfddZoeedYZddZpddZqdZrdddZsdZtejudZvevwesevxde"jyevdde$jzeve$j{eesdede$jzeve$j{eesdeddete#j|ev<deVfddZ}deVfddZ~eeddddZeedZddZeedZddZeedZddZde8fddZdNeVfddZeedYZddZ dddZdNeVfddZeedYZddZdNeVfddZeedYZdZdeVfddZeedZddZdNeVfddZeedZddZdeVfddZeedZddZdeVfddZeedzZddZdNe8fd dZeedYZddZdNeVfddZeedYZddZdNeVfd dZeedzZddZdNeVfd dZeedzZddZdNeVfd dZdNeVfd dÄZd?dNeVfddńZdeVfddƄZeedZddDŽZdeVfddȄZeedZddɄZde8fddʄZeedZdd˄ZdeVfddτZeeddeѦdd҄ZejedӦdeVfddՄZeeddeѦddքZdׄZeedudeѦd؄ZeedudeѦdلZeedzdeѦddڄZdeVfddۄZejudܦZejeexd݄e#jee$jzedބd߄ZdS() annotations)HashableSequence)partialN)index)Union)lax)choleskysvdeigh)config)core)dispatch)dtypes)prng) xla_bridge)jitvmap)ad)batching)mlir)_convert_and_clip_integer) _arraylikecheck_arraylikepromote_dtypes_inexact)Array ArrayLike DTypeLike)canonicalize_axisxrreturnrc,tj||SN)r ner s O/var/www/html/nettyfy-visnx/env/lib/python3.11/site-packages/jax/_src/random.py_isnanr'Ds 1F allow_batchednamestrkey KeyArrayLiker*booltuple[KeyArray, bool]ct|tr)tj|jtjr|}d}nt |rtj|t}d}tj j dkrtdtj j dkrtjddnKtjj rtjd t"nt%d t'||s.|jr't|d t+j|d ||fS) NFimplTerrorzLegacy uint32 key array passed as key to jax.random function. Please create keys using jax.random.key(). If use of a raw key array was intended, set jax_legacy_prng_key="allow".warn) stacklevelzjRaw arrays as random keys to jax.random functions are deprecated. Assuming valid threefry2x32 key for now.zunexpected PRNG key type z: accepts a single key, but was given a key array of shape " != (). Use jax.vmap for batching.) isinstancerr issubdtypedtypeprng_keyrr random_wrapdefault_prng_implr legacy_prng_keyvalue ValueErrorwarningsr5enable_custom_prng FutureWarning TypeErrortypendimnpshape)r+r-r* wrapped_keywrappeds r&_check_prng_keyrLHszU= 1#)V_ M M=KGG#="3->-@-@AAAKG #w..  9 : ::   % / /m 9EFHHHHH  " (m 5  ;S ;; < << R[-R QQ!x}}QQQ R RR g r(ctj|jtjsJt jjr|S|rtj |n|Sr#) jnpr:r;rr<r rCr@r random_unwrap) was_wrappedr-s r&_return_prng_keysrQksL  6? 3 3333 $; J&1 :4 c " " "s:r(KeyArray bit_widthintrIShapec|tj|jtjsJt j|||S)N)rSrI)rNr:r;rr<r random_bits)r-rSrIs r& _random_bitsrXts6  6? 3 3333 #% @ @ @@r(cxtjj}|tjvs J|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>{s7 &,) dj ) I r(cBeZdZUdZdgZded<dZd dZdd Zdd Z d S)PRNGSpecz$Specifies a PRNG key implementation._implPRNGImplc||_dSr#r^)selfr3s r&__init__zPRNGSpec.__init__s DJJJr(r!r,c*t|jSr#)r,r^rbs r&__str__zPRNGSpec.__str__sC OO3r(rTc*t|jSr#)hashr^res r&__hash__zPRNGSpec.__hash__sD$4$44r(r/c"|j|jkSr#ra)rbothers r&__eq__zPRNGSpec.__eq__s : $$r(N)r!r,)r!rT)r!r/) __name__ __module__ __qualname____doc__ __slots____annotations__rcrfrirlr(r&r]r]si,,i)///43334444%%%%%%r(r] impl_specPRNGSpecDesc | Noner_c|tSt|tur|St|tur|jSt|t urq|t jvrt j|Sddt j D}td|d|dt|}td|d)Nz, c3"K|] }d|dV dS)"Nrs).0ss r& z$resolve_prng_impl..s*==aQ======r(z"unrecognized PRNG implementation "z". Did you mean one of: ?zunrecognized type z$ for specifying PRNG implementation.) r>rFr_r]r^r,rrZjoinkeysrArE)rtkeys_fmtts r&resolve_prng_implrs    )__   )__  ? )__DJ Z ""yy==4:??+<+<=====H 9)99-5999 : :: 9oo!NqNNNOOOr( ctor_nameseedint | ArrayLikecNt|}t|dr6tj|jt jrt|dtj |r't|dtj |dtj ||S)Nr;z1 accepts a scalar seed, but was given a PRNG key.z8 accepts a scalar seed, but was given an array of shape z! != (). Use jax.vmap for batchingr2) rhasattrrNr:r;rr<rErHrGrIr random_seed)rrrtr3s r&_keyrs 9 % %$ T7Itz6? K KI  GGG I IIWT]]D   C C$ C C C D DD  $T * * **r(r2r3c$td||S)a0Create a pseudo-random number generator (PRNG) key given an integer seed. The result is a scalar array with a key that indicates the default PRNG implementation, as determined by the optional ``impl`` argument or, otherwise, by the ``jax_default_prng_impl`` config flag. 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 scalar PRNG key array, consumable by random functions as well as ``split`` and ``fold_in``. r-)rrr3s r&r-r-s" eT4  r(c@tdtd||S)aCreate a pseudo-random number generator (PRNG) key given an integer seed. The resulting key carries the default PRNG implementation, as determined by the optional ``impl`` argument or, otherwise, by the ``jax_default_prng_impl`` config flag. 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)rQrrs r&rrs " 4it!tj|g|R}||kr(d}t||||dSdS)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 {}.)r broadcast_shapesrAformat)r+rI param_shapesshape_msgs r& _check_shaperAsb8  !% 7, 7 7 7F Lc szz$66 7 77 88r(rsr;DTypeLikeUInt | Nonecztd|\}}|tjtj}ntj|tj|tjstd|tj|}tj |}|j dz}t|||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. bitsNzz_randint..sl3u55r(rr6)rrHrIrNr:integerrErasarrayr;astyperTr gtrriinforrrrrrrselect full_likeadd _lax_constremmul)r-rIrrr;maxval_out_of_rangek1k2rbits higher_bits lower_bitsunsigned_dtypespan multiplier random_offsetrs ` @r&rrs y%&!1!128F3C3CDDD rz * *I GGG H HH)VV,,, ;v  & ;v  &  bj 1 1 ]]3  F  bj 1 1 ]]3  F %ci %0@0@0De&L&Lfl [ []] %VU 3 3& $VU 3 3&  U 4 4&  U 4 4& )E   % /!! WPUWW X XX #;;&"b 5 5 5 5 5%!E"IIuuRyyz+u%. !&6/> B B$ Ff$cmD!&<&r r r z1method must be one of {'svd', 'eigh', 'cholesky'}NzCdtype argument to `multivariate_normal` must be a float dtype, got ) rLrrrrAr;r:rHrrr_multivariate_normal)r-rKrLrIr;rOrs r&rQrQsH 0# 6 6&#q#E***$T3//)$ ... H I II ] JE  5"+ . ., +#(++ , ,,   #E * *E c4eUF C CCr()rrctj|dks6d}t|tj|tj|dks6d}t|tj||jd}tj|dd||fkr8d}t||tj||0t j|jdd|jdd}n,td ||jdd|jdd|d kr6t|\}} } |tj | d dddfz} nJ|d kr5t|\} } | tj | d dddfz} nt|} t|||jddz|}tjd 5|tjd| |z}dddn #1swxYwY|S)Nrz@multivariate_normal requires mean.ndim >= 1, got mean.ndim == {}r6z>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}.)nrIr5r .r allowz...ij,...j->...i)rHrGrArrIr rrr rNr;r r r5r numpy_rank_promotioneinsum)r-rKrLrIr;rOrrVrJrzrfactorwvnormal_samplesr/s r&rRrRs_ !   LC SZZ .. / //    JC SZZ -- . .. jn!Xc]]233Aq6!! +C SZZ!28C==Z99 : :: ]  CRC#)CRC. A AEE5$*SbS/39SbS>BBB u__CIQ1 !CqqqL/** *FF  #YYFQ !CqqqL/** *FF c]]F#utz"##6>>. "7++KK CJ16>JJ JFKKKKKKKKKKKKKKK -sII Ilowerupperc,|tj|}td|\}}tj|tj|t jstd|tj |}t|||||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)``. Ntruncated_normalz@dtype argument to `truncated_normal` must be a float dtype, got ) rrrLrrr:rHrrAr_truncated_normal)r-r^r_rIr;rs r&raras@   #E * *E -s 3 3&#q#E***  5"+ . ., +#(++ , ,,  #E * *% 3ueU ; ;;r()rrc |:tjtj|tj|}n6t d|tj|tj|tjtjd|}tj||}tj||}tj||z }tj||z }tj |tj stdt|||||}|tj|z} tj| tjtj|tjtj|tjtj|tjtj |S)Nrar6z4truncated_normal only accepts floating point dtypes.rrr )r rrHrIrrr;rerfrNr:rrErrGcliprF stop_gradientinf) r-r^r_rIr;r>rbrJouts r&rbrbAsw ]  %"(5// B BEE#UBHUOORXe__MMM (271::u % %% "5% 0 0% "5% 0 0% geem! geem! r{ + +L J K KK c5%!444!  A#   mC%e,,bhrvU.K.K.KLL mC%e,,bhwe.L.L.LMM O OOr(?cr|tj|}td|\}}tjt j|}tj|tj s$d}t| |t j ||}t|||S)a Sample 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``. Returns: A random array with boolean dtype and shape given by ``shape`` if ``shape`` is not None, or else ``p.shape``. N bernoulliz=bernoulli probability `p` must have a floating dtype, got {}.)rrrLrrr r;rNr:rHrrErr _bernoulli)r-rrIrr;rs r&rmrmYs0   #E * *E ; , ,&#q  #CIaLL 1 1% r{ + +' IC CJJu%% & && q%((! CE " ""r(c|tj|}n#td|tj|t||t j||kS)Nrm)rHrIrrr r;r-rrIs r&rnrn{sO ] HQKKEEeRXa[[111 eSYq\\ * *Q ..r(ric,td|\}}tj|tj|tjst d|tj|}|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 ) rLrrr:rHrrArrr_beta)r-rrirIr;rs r&rrrrs< 63 ' '&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E sAq% ' ''r(c|:tjtj|tj|}n6t d|tj|tj|tj||}tj||}t |\}}tj||}tj||}t||||}t||||}tj ||} tj || z } tj || z } | | | zz S)Nrr) r rrHrIrrrrN broadcast_tologgammarexp) r-rrirIr;key_akey_b log_gamma_a log_gamma_blog_maxgamma_a_scaledgamma_b_scaleds r&rsrss ]  !bhqkk : :EE RXa[[999 q%((! q%((!,% q%  ! q%  !5%00+5%00+ GK - -'7;011.7;011. >N: ;;r(c$td|\}}tj|tj|tjst d|tj|}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 ) rLrrr:rHrrArrr_cauchyr8s r&rrs, 8S ) )&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% eU # ##r(c <td|t|||tj|jd}t |t j}tj tj |tj |t |dS)Nrrrdrk) rrrNrepsrrHpir tanrsub)r-rIr;rJrs r&rrszx c5% %(8(8(= 1, got alpha.ndim == {}r!r) rHrGrArrIrr rrv_softmax)r-rrIr;rlog_gamma_sampless r&rrs 1   DC SZZ// 0 00 ] HUOOCRC EEeRXe__SbS%9::: "5% 0 0%sE528E??2333G+GOO #R ( ((r(c,tj|jtjst d|jt j||d}t j|tj |z }|| |dz S)z7Utility to compute the softmax of x along a given axis.z+_softmax only accepts floating dtypes, got T)keepdims) rr:r;rHrrErNrrwr rgsum)r rx_max unnormalizeds r&rr)s  17BK 0 0M K!'KK L LL '!TD ) ) )%S.u55566,  (((== ==r(c$td|\}}tj|tj|tjst d|tj|}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 ) rLrrr:rHrrArrr _exponentialr8s r&rr2s, =# . .&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% c5% ( ((r(ctd|t|||}tjtjtj|S)Nr)rrr neglog1pr-rIr;rJs r&rrQsE}e$$$ c5%  ! 371::&& ' ''r(c t|dt|dt|dt|dt|d}t|dtj|tj|}|}tj||tj|}tj||tj|tjfd}fd}t|\}}tj |||t|d f\} } } } |rtj t|d  } tj|| dkztj | tj|} tjtjtjtj| | Sdt|d  z } tj|tj| tj|}tj tj | |S) Nrrr!rkgUUUUUU?gm{?c|\}}}}tjtj|tjtj tj||tjtj|tjtj|tjtjtj|tj|}|Sr#)r bitwise_andgerrrr) kXVUrXVUconddone one_over_two squeeze_consts r&_cond_fnz_gamma_one.._cond_fnusJAq!Q ?36!SWS#'-QRTU2W2W%X%XYY6#'!**cgcga6N6N69gaQTVWILQRBUBU7V7V/W/WXX Y YD Kr(c4 fd}|d}t|d\}}}tjfd|| f\}}}tj||}tjtj|||} t |d } ||| | fS)Nc|d}t|\}}t|d}tjtj|}|||fS)Nrrsr )rr5r rr)kxvr-rr r\cr;rs r& _next_kxvz/_gamma_one.._body_fn.._next_kxvsV Fc3KKkc6 5 ) ) )a '#swq!}} % %a !QYr(rrc:tj|dS)Nr6)r le)rzeros r&rz._gamma_one.._body_fn..sA)=)=r(rsr )rr while_looprr)rrr-x_keyU_keyrr r\rrrrr; minus_onerrs r&_body_fnz_gamma_one.._body_fns q'CsACn====y5RVXaJbccGAq! 1 A 1 q!!Ar'''A 1a<r(r6rsr )rr r;rrrrdivr;rrrrrrrpow)r-r log_spaceone_over_three boost_mask alpha_origrrrrr log_samples log_boostsamplesboostrrr;rrrrrs @@@@@@@@r& _gamma_onerYsX E1  $5!###)E3'',eW--.UF++- )E  %veS!!** *Zs(;(; < <% ge^$$! gnchqkk**!        "s +#v~h3c:eUVCWCW2XYY*!Q1)'+fb>>>??K :)9:D#'+WZW^_bdnWoWoBpBpqqI 737371::swqzz22I > >>'&"E2222G Jz3j9Q9Q(R(R S SE 7371a==% ( ((r(cptj|d}tj|d}|rtj|}t j|d}tj|tj|jj }tj tj ||||}dn tj tjjdkrtjfd||f}nt#||}|t%j|S)Nr!rc2tj|||z Sr#)r random_gamma_grad)rsamples r&rz_gamma_grad..ss'.sT!2r()rNrr rw lax_internal_constrrr;tinyreqrr get_backendplatformmaprrHrI) rrrralphasrrgradsrs @r& _gamma_gradrs  K # #' ;q"  & 'ggG  vq ) )D =#)GM":":"? @ @Dj..g>>GTTJJ&J&%// G2222VW4E F FEE D  VW - -E rx{{ # ##r()use_vmapctj|}tj||jd}|}t td||}|}|}|rIt|tj ur.t tt||}ntjfd||f}tj||S)N)rN)in_axesrct|diS)Nr)r)rrs r&rz_gamma_impl..sZ;;;r()rNrIr"r#rGflattenrrrrthreefry_prng_implrrr rr) r-rrra_shape split_countr~rrs ` r& _gamma_implrs IaLL' '#()),--+ $ (fi ( ( ({ ; ;$ $ 99;;& M)C..D$;;;.s9MMQamagajmmmmMMr(rr)nextzipr bdim_at_frontrandom_gamma_pbind) batched_args batch_dimsrkrbkbars r&_gamma_batching_rulers $!Q &"b MM z::MMM M M$QD))!QD))!   QY  7 7 ::r( random_gammac *tj|Sr#)rraise_to_shaped)r-rrs r&rrsT5I!5L5Lr(c $|t||fi|zSr#)r)tangentansr-rkwdss r&rrs;sA3N3N3N3N)Nr()multiple_resultsr)rc,td|\}}tj|tj|tjst d|tj|}|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 NrIr; rLrrr:rHrrArrr_gammar-rrIr;rs r&rrsH 7C ( (&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E Qe5 1 1 11r(c.td|\}}tj|tj|tjst d|tj|}|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. rvrNTrIr;rrrs r&rvrvs> :s + +&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E Qe5D A A AAr(r)static_argnamesc4|tj|}n#td|tj|tj||}tj||krt j||}t|||S)Nrr) rHrIrr rrNrurr)r-rrIr;rs r&rr2s ] HQKKEE%!--- q%((!Xa[[E E""A   S!y  9 99r()r6rrcfd}fd}tjd|}tjdtj}tj||d|||fd} | dz |S)Nc|\}}}}t|\}}tj| k|dz|}t|tj}|dz|||t j|zfSNr)rr rrrHfloat32rNr) carryrrrnglog_prodrrJlamrIs r&body_fnz_poisson_knuth..body_fnEspAq#x++KC 8sd?AE1--Arz**A q5!S(SWQZZ/ //r(cd|d|d}}| k|kzS)Nrrany)rrrr max_iterss r&cond_fnz_poisson_knuth..cond_fnLs5(E!HxA tO " "a)m 44r(rr)r rrHrrr) r-rrIr;r rr k_init log_rate_initrs `` ` r&_poisson_knuthr ?s 000000555555 =a . .&-Q E::- nWg63 'FGGJ! a%  r(c tj ddtjzz dd zz dd dz z z dd d z z z   fd }fd }tjd j}tjdt j}tj||d|||fd} | |S)Ngn?= ףp=@gh|?5g[ m?g$~?gr?g333333 @gr鷯?gB>٬ @r6c8|\}}}}t|d\}}}t|jdz }t|j}dt|z } t jdz| z z|zzdz} t j|z| | zz zz }  | zzt j| dzz } | dk|kz} | dk| dk|| kzz}| | k}| ||zz}t j|| |}||z}|dz|||fS) Nrrkr6gQ?rQ?rg9v?) rrr;absr floorrlgammar)rrk_outacceptedr-subkey_0subkey_1rJr\ u_shiftedrrzraccept1rejectaccept2acceptrri inv_alpharlog_lamrIv_rs r&rz#_poisson_rejection..body_fnasN#Auh$S!nnC8%++c1A%++Ac!ff I 1q59$q(A-3d:;;A I i)&;!F1fG ') *F Jvq% ( (E H q5%3 &&r(cJ|\}}}}||kzSr#r)rrrrr-r s r&r z#_poisson_rejection..cond_fnws,#Auh I??  I ..r(r!Frr) r rr;rr;rNbool_rr)r-rrIr;r rr r rrrrirrr s `` ` @@@@@r&_poisson_rejectionr#Vs GCLL' dSXc]]""! w{!vS)))1q5!!#''''''''''',///// =b#)U 3 3& ]3sy% 8 8( nWg68S'ABB1E! %r(c t||dkz}tj||tj|d}tj|tj|d|}|t j|j}tj|t|||||t|||||}tj|dkt j ||S)N rgj@r) r'r rrrFrNrrr r# zeros_like) r-rrIr; use_knuth lam_knuth lam_rejectionr r/s r&_poissonr*sSkkS2X&)jCsC)@)@AA)*Y c3(?(?EE-jj5))-..) : 3 5%;;sM5%CC  & C1HcnV44f = ==r(rctd|\}}tj|tjt j|j}|j}|t j urtd|tj |}|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 )rLrrrrrrr;r^rNotImplementedErrorrrrrHrIrNrur rrr*)r-rrIr;rrrs r&r,r,s2 9c * *&#q#E***{4:sy11*  ( T,,,        #E * *%   #E * *EE HSMME e$$#  bj11# #sE5 ) ))r(c$td|\}}tj|tj|tjst d|tj|}tj |}t|||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). Returns: A random array with the specified shape and dtype. r(z6dtype argument to `gumbel` must be a float dtype, got ) rLrrr:rHrrArrr_gumbelr8s r&r(r(s( 8S ) )&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% eU # ##r(c td|tjtjt|||tj|jd  S)Nr(rrd)rrNrrrrr-rIr;s r&r/r/shx '37 c5% %(8(8(=bIIIKKK L L LLr(r!logitsc Ftd|\}}td|tj|}|dkr|t |jz}t tj|j|}||}n%tj |}td|||dt |t |z }t|t |t |z d}| |t |jz|j|tjt|g||R|jt#j|t t't |z|S)aSample random values from categorical distributions. 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)``. Returns: A random array with int dtype and shape given by ``shape`` if ``shape`` is not None, or else ``np.delete(logits.shape, axis)``. categoricalrNr)rLrrNrrrIrrHr+rrrlistr*argmaxr(r;r expand_dimsr) r-r2rrIr logits_arr batch_shape shape_prefix logits_shapes r&r4r4s& =# . .&#q-((({6""* QYYC  ! !!Dbi 0$7788+ ] EE  #E * *E{3333E 3{#3#3334,eCJJ[)9)99::;<<,dS!1222J4DT4JKKK  S0L0<00*2BCC oj%c,.?.?(@(@"A"ABBC    r(c$td|\}}tj|tj|tjst d|tj|}tj |}t|||S)aSample Laplace random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x) = \frac{1}{2}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). Returns: A random array with the specified shape and dtype. laplacez7dtype argument to `laplace` must be a float dtype, got ) rLrrr:rHrrArrr_laplacer8s r&r>r>s( 9c * *&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% #ue $ $$r(c 8td|t|||dtj|jzd}t jt j|t jt j t j |S)Nr>rErrd) rrrNrepsnegr rsignrrrrs r&r?r?.s|y%     5%ci&6&6&= =bJJJ! !ci (;(;<< = ==r(c$td|\}}tj|tj|tjst d|tj|}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 ) rLrrr:rHrrArrr _logisticr8s r&rDrD6s( :s + +&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% 3u % %%r(c td|t|||tj|jd}t jt j|t jt|d|S)NrDrrdr) rrrNrrr rrrr)r-rIr;r s r&rErESsiz5!!! c5% %(8(8( 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 ) rLrrr:rHrrArrr_pareto)r-rirIr;rs r&rHrHZs6 8S ) )&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E a & &&r(c|tj|}ntd|tj||}t |||}tj||z S)NrH)rHrIrr rrrw)r-rirIr;es r&rIrIs[ ] HQKKEE5!!! q%((!#ue$$! Qr(dfc&td|\}}tj|tj|tjst d|tj|}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 ) rLrrr:rHrrArrr_tr-rLrIr;rs r&rrs6 3 $ $&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% CUE " ""r(c|tj|}n#td|tj|tj||}t |\}}t |||}t|d}tj||}t||||} |tj || z zS)Nrr6) rHrIrr rrr5rrrrNr;) r-rLrIr;key_nkey_grVtwohalf_dfr3s r&rNrNs ] HRLLEEeRXb\\*** E**",% UE5!!!1a# GB  ' E7E5))! SXgk " " ""r(c*td|\}}tj|tj|tjst d|tj|}|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 ) rLrrr:rHrrArrr _chisquarerOs r&rVrVs8 ; , ,&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E CUE * **r(cb|tj|}n#td|tj|tj||}t |d}tj||}t||||}tjtj ||}|S)NrVr6)rrIr;) rHrIrr rrrrvrrNrw)r-rLrIr;rSrTlog_gchi2s r&rWrWs ] HRLLEEeRXb\\222 E**"2q# GB  ' 3'e < < <%  % %$ +r(dfnumdfdenc,td|\}}tj|tj|tjst d|tj|}|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``. fz1dtype argument to `f` must be a float dtype, got ) rLrrr:rHrrArrr_f)r-r[r\rIr;rs r&r^r^sD 3 $ $&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E Cue , ,,r(c||:tjtj|tj|}n6t d|tj|tj|tj||}tj||}t |\}}t||||}t||||}tj ||}tj ||}tj ||} tj ||} tj | | } | S)Nr^) r rrHrIrrrrVrNrur) r-r[r\rIr;key_dfdkey_dfnchi2_dfnchi2_dfdrdenr^s r&r_r_s ]  !"(5//28E?? C CEEeRXe__bhuoo>>> "5% 0 0% "5% 0 0%C[['7 wue 4 4( wue 4 4( 5% ( (% 5% ( (% %  # %  # gc3! (r(ctd|\}}tj|tj|}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)rLrrrrr _rademacherr8s r&rgrg3sZ, < - -&#q#E***  #E * *%  !% ( (% S% ' ''r(ct|d||}d|zdz |S)Nrkrpr6r)rmr)r-rIr;bernoulli_sampless r&rhrhPsDC3e<<<CCEJJ  ! # + +E 2 22r(c$td|\}}tj|tj|tjst d|tj|}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 ) rLrrr:rHrrArrr_maxwellr8s r&rlrlVs. 9c * *&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% #ue $ $$r(cr|dz}t|||}tj|dS)N)rr1r!r5)r5rNlinalgnorm)r-rIr;norm_rvss r&rmrmws7 $,% 5 6 6 6(  + ++r(locscalec(td|\}}tj|tj|tjst d|tj|}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 ) rLrrr:rHrrArrr_double_sided_maxwell)r-rrrsrIr;rs r&ruru~s4 13 7 7&#q#E***  5"+ . .- ,$),, - --  #E * *%  !% ( (% sCu = ==r(c,tjtj|tj|}|s|}||z}t |\}}t |||}t |||} | j|jksJ| |z|z|zS)Nr)r rrHrIrrlrg) r-rrrsrIr; params_shapes maxwell_keyrademacher_key maxwell_rvs random_signs r&rvrvs&rx}}bhuooFF-  E - % &s +~ 5>>>+>eDDD+  k/ / / / / { "U *S 00r( concentrationc(td|\}}tj|tj|tjst d|tj|}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 ) rLrrr:rHrrArrr _weibull_min)r-rsr}rIr;rs r&rrs4 =# . .&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% c5- > >>r(ct||dd|}tjtj|  d|z |zS)Nrr)r-rIrrr;r)rrNpowerr)r-rsr}rIr;random_uniforms r&rrsN U1Qe===. CI~o...M0A B BU JJr(rVc 2tj|}td|\}}tj|t d|tjt|d}t|g|||R|}tj |\}}tj |ddd}tj|tjtj|t#||jdgS)aSample uniformly from the orthogonal group O(n). If the dtype is complex, sample uniformly from the unitary group U(n). Args: key: a PRNG key used as the random key. n: an integer indicating the resulting dimension. 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, n, n)` and specified dtype. orthogonalz-The error occurred in jax.random.orthogonal()rrUr!)rrrLrrrrrr5rNroqrdiagonalr rr8rrrr;) r-rVrIr;rzqr rs r&rrs(  !% ( (% < - -&#q#E***|U### UA'VWW! S.E.1.a..%((! q  $!Q l1aR  ! COCGAs1vv}}QW/E/E$F$FMM N NNr(floatc0tj|}td|\}}tj|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) rrrLrrrrrrg)r-rrIr;rr~r3r s r&rrs4  !% ( (% / 5 5&#q#E***#U+++ s$ DGQqS%''!a%''! Q1q5\ r(rctj|}td|\}}tj|t d|tjt|d}t|\}}t||g||R|}t|||} |tj ||z d| 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)rrrLrrrrrrrrrNrr) r-rrrIr;rrrr3rKs r&rr s,  !% ( (% 63 ' '&#q#E***vu UA'PQQ! ::&"bQ %  U33!"eU##!  a$$R((1,!a%8) D DDr(c*td|\}}tj|tj|tjst d|tj|}|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 ) rLrrr:rHrrArrr _rayleigh)r-rsrIr;rs r&rrAs8 :s + +&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E 3ue , ,,r(c|tj|}n#td|tj|t|||}||}t j||}tj|}t|d}tj tj ||}tj ||}|S)NrrU) rHrIrrrrNrur rrr;r) r-rsrIr;rJlog_un_twosqrt_urays r&rrgs ] HUOOEEUBHUOO444 c5%  ! ,,u  % 5% ( (% '!**% UB  % 8CGE5)) * *& v# *r(c*td|\}}tj|tj|tjst d|tj|}|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 ) rLrrr:rHrrArrr_wald)r-rKrIr;rs r&rrvs: 63 ' '&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E sD% ' ''r(c|tj|}n#td|tj|t|d\}}||}t j||}t|||}t|||}tj |d}tj |d} tj |d} tj d|z|z| | zz} || |zdz z|dz | zz } tj tj |||| zz | | | z } | S)Nrr6r)rHrIrrrrNrur5rr integer_powr;rr)r-rKrIr;rrr\ryy_sqmean_sq sqrt_termr r[s r&rrs* ] Xd^^EE/// #q>>&"b U  $ $ & &$ R! b%! oa! A  $ OD! $ $'hq4x!|gn455) Wq[1_tax)33! jDD1H-..7Q;??! (r(c*td|\}}tj|tj|tjst d|tj|}|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 ) rLrrr:rHrrArrr _geometric)r-rrIr;rs r&rrs6 ; , ,&#q#E***  5"* - -, +#(++ , ,,  #E * *%   #E * *E CE5 ) ))r(c|tj|}n#td|tj|td|t |\}t |||j}tj|}tj | }tj ||}tj tj ||dz}||S)Nrr)rHrIrrrrr;r rrrNrurrr)r-rrIr;rJrlog_one_minus_pr3s r&rrs ] Xa[[EEeRXa[[111+q!!!a  "! c5!'""! '!**%IqbMM/$_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 ) rLrrr:rHr6rArrr _lognormal)r-rrIr;rs r&rr% s2 ; , ,&#q#E***  5"* - -% $!$$ % %%  #E * *%   #E * *E Cu - --r(c|tj|}n#td|tj|tj||}t ||||z}t j|S)Nr)rHrIrrNrur5r rw)r-rrIr; scaled_norms r&rrH sh ] Xe__EEubhuoo666 5% ( (%sE5))E1+   r(c6tjgd|j}|dk}tjd|d}|dz|dzz}ddd |z z |z z |dzz }tj|}tj||tj||S) N) gW ڼq?g;>*?g&W?gxb&J?g?QN ?g{k?g^J.aM]?g?0{^R?gb?gCL?r  rg"@rgUUUUUU?gllf?gJ?)rNrr;r clamprrint32)rstirling_tail_valsuse_tail_valueskp1sqapproxs r&_stirling_approx_tailrS sy    GF/ iQ! q5QU %  J$66%? ?AE J& ill! O%7 ! %Ev N NNr(c tjjr&tjjtjsJtj   fd}fd}tj dj}tj dj} d|| |f} tj ||| d} | dz |S)Nc |\}}}}t|\}}tj| k|dz|}t| j}t jt j| z }||z}|dz|||fSr)rr rrr;rNrr) rrnum_geomgeom_sumr-r num_geom_outrJgeomcount log1minusprobprobrIs r&rz$_binomial_inversion..body_fnr s!&Ax3**KFC:h%/AxHHLtz**A 8CGAJJ. / /D$H q5,# --r(cb|d|d}}|k|kzSNrr6r)rrrrr s r&r z$_binomial_inversion..cond_fn{ s4(E!HxA   " " $ $I 66r(rr) r enable_checksr@rNr:r;rrr rrr) r-rrrIr;r rr  num_geom_init geom_sum_initrrrs ``` ` @r&_binomial_inversionrk s 4 >$*cl 3 3333)TE""-........777777-aU;;--aU;;- m]C 0% nWgu--a0! 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| tjdtj|f} tj||| d |S)Nrgffffff?rgEJYga+e?{Gz?rkgq= ףp?g@gp= ף@gffffff@cv |\}}}}t|d\}}}t|j}t|j}|dz }dtj|z } | dk|kz} tjdz| z z|zz} | dk| kz} tj|z| | zz zz }dztjdzz dzzz zdztjz dz| z dzz zz| dztj| z dzz| dzz zztztz zt| z t| z z } || k}| | |zz}tj || |}||z}|dz|||fS)Nrrkrr6rr) rrr;rNrrrrr r)rrrrr-rrrJr\usrrrubrrrrrirrmrr rIr s r&rz_btrs..body_fn s#Auh#CmmC8%,,A%,,A CA swqzz BTza3h'G 1q52:>Q&*++A!eE "F E Q"r']Q./00A3w#'1q5Q%!)a-%89::: cguqy1}Q?@@@A SCGAQ/1q59:::; a  ! eai(( ) a  ! eai(( )2gG ') *F Jvq% ( (E H q5%3 &&r(c\|d|d}}||kzSrr)rrrr s r&r z_btrs..cond_fn s/(E!HxA I??  I ..r(r!rF) rNr;rr rr;fullr"rr)r-rrrIr;r stddevrr r rrrrirrr r s ``` ` @@@@@@@r&_btrsr s` 8EDLAH- . .& TF]!  TD[(! dlS! sQw# a$h! #'>V #% id"##!''''''''''''''4///// =r4:u 5 5& fchueSY77 =% % 0 0 3 : :5 A AAr(c |:tjtj|tj|}n6td|t j|t j|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|}|tj|j}t j | t%|| ||||t'|| ||||}| | z|z}t j |tj |tj||}t j ||ztj |tj||}t j ||z| z|z||||z }|S)Nbinomialrkrrrg$@g@)rNrrIrrHrr rr;rurr'isinfrrrFrrrrnanrhr)r-rrrIr; p_lt_halfrcount_nan_or_neg count_infq_is_nanq_l_0 use_inversion count_inv count_btrsq_btrsr rinvalids r& _binomialr s  ]  5!1!139T?? C CEEUBHUOORXd^^DDD "4 ( ('4 "5$* 5 5% 5% ( (% $ & &$Sj) jD#*--!E]]eck2i) AYY( c'% jE!3=D#9#91==!"eai4&78- )E  %js}UC/H/HII)z-uc)B)BEJJ* :mS]1c%:%:A > >&jj5))-..) JY5%CC #z65%;;  'X  0 0' J M'37E**   ' J 'M'37E**   ' J   8+i7  LL'!  ' .r(cHtd|\}}td||tj|tj|t jstdtj|}|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``. rz?dtype argument to `binomial` must be a float dtype, got {dtype}) rLrrrr:rHrrArrrr)r-rVrrIr;rs r&rr sD :s + +&#q*a####E***  5"+ . . I    #E * *%   #E * *E 31eU + ++r( random_clonec|Sr#rsr%s r&rr# s1r(c|gSr#rs)rrs r&rr% sQCr(c6t|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)r-s r&cloner' s   S ! !!r()r rr!r)r+r,r-r.r*r/r!r0)r-rRrSrTrIrUr!r)rtrur!r_)rr,rrrtrur!rR)rrr3rur!rR)r-r.rrr!rR)r-rRrrr!rR)r-r.rrr!rR)r~rRr!r_)r~r.r!r)r~rRr!r)r~r.r!r)rrr3ru)r+r,rIrUr!r)rsN)r-r.rIrUr;rr!r) r-r.rIrUr;rrrrrr!r)r!r) r-r.rIrUrrrrr;rr!r)rF) r-r.r rrrTrr/r!r)rsTNr)r-r.rrrIrUrr/rrrrTr!r)r-r.rIrUr;rr!r)NNr )r-r.rKrrLrrIrMr;rNrOr,r!r) r-r.r^rr_rrIrMr;rr!r)r-r.rrrIrMr!r) r-r.rrrirrIrMr;rr!r) r-r.rrrIrMr;rr!r)r-rRr!r) r-r.rrrIrMr;rr!r)F) r-r.rrrIrMr;rr!r)r!N) r-r.r2rrrTrIrMr!r) r-r.rirrIrMr;rr!r) r-r.rLrrIrUr;rr!r) r-r.rLrrIrMr;rr!r) r-r.r[rr\rrIrMr;rr!r)r-r.rIrUr;rr!r) r-r.rrrrsrrIrUr;rr!r) r-r.rsrr}rrIrUr;rr!r) r-r.rVrTrIrUr;rr!r) r-r.rrrIrUr;rr!r) r-r.rrTrrrIrUr;r) r-r.rsrrIrMr;rr!r) r-r.rKrrIrMr;rr!r) r-r.rrrIrMr;rr!r)r-r.rrrrrrrIrMr;rr!r) r-r.rrrIrMr;rr!r) r-rRrVrrrrIrMr;rr!r) __future__rcollections.abcrr functoolsrr"operatorrrrrBnumpyrH jax.numpyrNjaxr jax.numpy.linalgr r r jax._srcr rrrrr jax._src.apirrjax._src.interpretersrrr jax._src.laxrjax._src.numpy.lax_numpyrjax._src.numpy.utilrrrjax._src.typingrrr jax._src.utilrrrr DTypeLikeUIntrrTrUr_rRr.rrrr'rLrQrXr>r]r, PRNGSpecDescrrr-rrrrrrrrrrrrrrrrrr rr5r7r=rQrRrarbrrmrnrrrsrrrrrrrrrrr Primitiverdef_impldef_abstract_evaldefjvp2register_lowering lower_funprimitive_batchersrrvrr r#r*r,r(r/r4r>r?rDrErHrIrrNrVrWr^r_rgrhrlrmrurvrrrrrrrrrrrrrrrrrrrrr simple_impl defvectorizedrrsr(r&r s#"""""........  0000000000""""""""$$$$$$******&&&&&&,,,,,,>>>>>>SSSSSSSSSS7777777777++++++       =     +0      F;;;AAAA" % % % % % % % %$S(H,- PPPP. + + + +%)!!!!!!()->>>>>>(----& - - - - - < < < < < )))) """"/3999999*8888'+-----<$) " " 55555: V$$$%?%?%?%$%?X#& 555554 V$$$;I;I;I%$;I@$)55555> T"""   #" :!% JLJLJLJLJL\#($$$$$> V$$$ + + +%$ + V$$$>>>%$>/37;&0 0D0D0D0D0Dd Y'''('F,0-2 (<(<(<(<( V$$$>>>%$>%)&++.+.+.+.+.Z V$$$)))%$)">>>> "(-)))))> V$$$(((%$(A)A)A)A)H$$$(05'''''";;; // $$$ !L!LMMM  DNNPPP~~t~ GK$'''(((~~t~ GK$'''(((&+----/CN+!%"',2,2,2,2,2b$(%*'B'B'B'B'BT =>>> : : : :?> : Y'''(', Y''''''(''T V$$$>>>%$>,#'"%**********\#($$$$$: V$$$LLL%$L&*'''''V$)%%%%%: V$$$>>>%$>%*&&&&&: V$$$;;%$;"&#(#'#'#'#'#'J V$$$%$#"#"#"#"#"#H V$$$ # # #%$ #"%)&+$+$+$+$+$+L V$$$   %$  !# *-*-*-*-*-X V$$$   %$ (!%((((((: V$$$333%$3 $)%%%%%B V$$$,,,%$,)+16 !>!>!>!>!>H V$$$ 1 1 1%$ 1$ "(- !?!?!?!?!?H V$$$KKK%$K OOOOOB !!!!!L EEEEEF$(%*$-$-$-$-$-L V$$$    %$  $!&%(%(%(%(%(N V$$$   %$ (%)$'#*#*#*#*#*J V$$$   %$ &&*', ,;,;,;,;,;\ VD111   21 $",A$(&+!.!.!.!.!.F VD11121OOO0 Yt444544 Yt444,B,B54,B^ VD111777217|! ,,,,,,,,,,` //^$$$ ---~&&&~'7'7888"""""r(