Wh l ddlmZddlmZddlmZddlZddlmZddl Z ddl m Z ddl Z ddl Z ddlm ZddlmZddlmZmZmZdd lmZdd lmZdd lmZdd lmZdd lmZddlmZddlmZmZddl 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.m/Z/ddl0m1Z1e.Z2e.Z3e/Z4e/Z5e/Z6ee7Z8ej9Z9ej:Z:e%j;Zd%Z?dd*Z@d+ZAGd,d-ZBe eCeBe9fZDdd1ZEdd5ZFdd6dd8ZGdd6dd9ZHdd<ZIdbdd@ZJdbddAZKddCZLddEZMddFZNddGZOddHZPdd6ddJZQddLZR dddPZSdMeTdQdRfddWZUeedXYddZZVe7fdd\ZWeed]Ydd^ZX dddaZYeedbYddcZZ dddiZ[dMeTfddjZ\eedXYddkZ]eedXYddlZ^ dddsZ_eedtYdduZ`deTfddxZaeedyYddzZbe jcd{dfdd|ZdeedbYdd}ZedeTfddZfddZgdMeTfddZheedXYddZideTfddZjeedYddZkddZldMeTfddZmeedXYddZnddZodZpdddZqdZrejsdZtetueqetvde!jwetdde#jxete#jyeeqddde#jxete#jyeeqddddere"jzet<deTfddZ{deTfddZ|eeddddZ}eedYddZ~eedYddZeedYddZde7fddZdMeTfddZeedXYddZ dddZdMeTfddZeedXYddZdMeTfddZeedXYdZdeTfddZeedYddZdMeTfddZeedYddZdeTfddZeedYddZdeTfddZeedyYddZdMe7fd dZeedXYddZdMeTfddZeedXYddZdMeTfd dZeedyYddZdMeTfd dZeedyYddZdMeTfd dZdMeTfd d„Zd=dMeTfddĄZdeTfddńZeedYddƄZdeTfddDŽZeedYddȄZde7fddɄZeedYddʄZdeTfdd΄ZeedddЦddфZe jcdҦdeTfddԄZeedddЦddՄZdքZeedtddЦdׄZeedtddЦd؄ZeedyddЦddلZdeTfddڄZejsdۦZejeevd܄e"jee#jxed݄dބZdS() annotations)Sequence)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)rners U/var/www/html/movieo_spanner_bot/venv/lib/python3.11/site-packages/jax/_src/random.py_isnanr&Bs 1F allow_batchednamestrkeyr)booltuple[Array, 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 ValueErrorwarningsr3enable_custom_prng FutureWarning TypeErrortypendimnpshape)r*r,r) wrapped_keywrappeds r%_check_prng_keyrJFszU= 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") jnpr8r9rr:r rAr>r random_unwrap) was_wrappedr,s r%_return_prng_keysrOisL  6? 3 333 3 $; J&1 :4 c " " "s:r' bit_widthintrGShapec|tj|jtjsJt j|||S)N)rPrG)rLr8r9rr:r random_bits)r,rPrGs r% _random_bitsrUrs6  6? 3 333 3 #% @ @ @@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<ys7 &,) dj ) I r'cJeZdZUdZdgZded<dZddZddZdd Z dd Z d S)PRNGSpecz$Specifies a PRNG key implementation._implPRNGImplc||_dSr")r[)selfr1s r%__init__zPRNGSpec.__init__s DJJJr'r r+c"d|jjdS)Nz PRNGSpec())r[r*r^s r%__repr__zPRNGSpec.__repr__s +tz + + ++r'c*t|jSr")r+r[rbs r%__str__zPRNGSpec.__str__s tz??r'rQc*t|jSr")hashr[rbs r%__hash__zPRNGSpec.__hash__s   r'r-cLt|to|j|jkSr")r7rZr[)r^others r%__eq__zPRNGSpec.__eq__s eX & & D4:+DDr'N)r r+)r rQ)r r-) __name__ __module__ __qualname____doc__ __slots____annotations__r_rcrerhrkr'r%rZrZs,,i)///,,,,EEEEEEr'rZ 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)"Nrr).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<rDr\rZr[r+rrWjoinkeysr?rC)rskeys_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)Nr9z1 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 batchingr0) rhasattrrLr8r9rr:rCrFrErGr random_seed)rrrsr1s r%_keyrs 9 % %$ T7Itz6? K KI  GGG I IIWT]]D   C C$ C C C D DD  $T * * **r'r0r1c$td||S)aiCreate a pseudo-random number generator (PRNG) key given an integer seed. The result is a scalar array containing a key, whose dtype indicates the default PRNG implementation, as determined by the optional ``impl`` argument or, otherwise, by the ``jax_default_prng_impl`` config flag at the time when this function is called. 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,)rrr1s r%r,r,s$ eT4  r'c@tdtd||S)aCreate a legacy PRNG key given an integer seed. This function produces old-style legacy PRNG keys, which are arrays of dtype ``uint32``. For more, see the note in the `PRNG keys `_ 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)rOrrs r%rrs 4 4it!>Ar'cJtd|d\}}t|S)Nkey_implTr()rJr)r} typed_keys_s r%rr/s(!*d$GGG-*a :  r'cvtj|jtjsJt j|Sr")rLr8r9rr:rrM)r}s r% _key_datar4s/  FO 4 444 4 D ! !!r'cJtd|d\}}t|S)z9Recover the bits of key data underlying a PRNG key array.key_dataTr()rJr)r}rs r%rr8s& JD A A A'$ 4r'key_bits_arraycLt|}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. r0)rrr;)rr1impl_objs r% wrap_key_datar>s't $ $( .x 8 8 88r'Nonec|r>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 {}.)rbroadcast_shapesr?format)r*rG param_shapesshape_msgs r% _check_shaperSsb8  !% 7, 7 7 7F Lc szz$66 7 77 88r'rrr9DTypeLikeUInt | 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'rr4)rrFrGrLr8integerrCrasarrayr9astyperQrgtrriinforrrrrrrselect full_likeadd _lax_constremmul)r,rGrrr9maxval_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!&<&Wx''  =W = =$ = = = > >>YR C8 , ,ch!mmss#sD)A)Affd ~$g'88f3CHMMsDII&QffHa   #A & &FE {xk!!  H H Hr r r z1method must be one of {'svd', 'eigh', 'cholesky'}NzCdtype argument to `multivariate_normal` must be a float dtype, got ) rJrrrr?r9r8rFrr r_multivariate_normal)r,rMrNrGr9rQrs r%rSrSsH 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 == {}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}.)nrGr7r .r allowz...ij,...j->...i)rFrEr?rrGrrrr rLr=r r r7r numpy_rank_promotioneinsum)r,rMrNrGr9rQrrXrLryrfactorwvnormal_samplesr1s r%rTrTs_ !   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 ) r rrJrrr8rFrr?r_truncated_normal)r,r`rarGr9rs r%rcrc1s@   #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)Nrcr4z4truncated_normal only accepts floating point dtypes.rrr$)rrrFrGrrr=rerfrLr8rrCrrIcliprH stop_gradientinf) r,r`rarGr9r@rbrLouts r%rdrd[sw ]  %"(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 {}.)r rrJrrrr9rLr8rFrrCrr _bernoulli)r,r rGrr9rs r%roross0   #E * *E ; , ,&#q  #CIaLL 1 1% r{ + +' IC CJJu%% & && q%((! CE " ""r'c|tj|}n#td|tj|t||t j||kS)Nro)rFrGrrrr9r,r rGs r%rprpsO ] HQKKEEeRXa[[111 eSYq\\ * *Q ..r'rkc,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 ) rJrrr8rFrr?rr r_beta)r,rrkrGr9rs r%rtrts< 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)Nrt) rrrFrGrrrrL broadcast_tologgammarexp) r,rrkrGr9key_akey_b log_gamma_a log_gamma_blog_maxgamma_a_scaledgamma_b_scaleds r%rurus ]  !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 ) rJrrr8rFrr?rr r_cauchyr:s r%rrs, 8S ) )&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% eU # ##r'c <td|t|||tj|jd}t |t j}tj tj |tj |t |dS)Nrrrfrm) rrrLrepsrrFpirtanrsub)r,rGr9rLrs r%rrszx c5% %(8(8(= 1, got alpha.ndim == {}r%r) rFrEr?rrGrrrrx_softmax)r,rrGr9rlog_gamma_sampless r%rr1s 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) rr8r9rFrrCrLrryrrisum)rrx_max unnormalizeds r%rrCs  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 ) rJrrr8rFrr?rr r _exponentialr:s r%rrLs, =# . .&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% c5% ( ((r'ctd|t|||}tjtjtj|S)Nr)rrrneglog1pr,rGr9rLs r%rrksE}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%rmgUUUUUU?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_fnsJAq!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)Nrrrr$)rr7rrr)kxvr,rrr^cr9rs r% _next_kxvz/_gamma_one.._body_fn.._next_kxvsV Fc3KKkc6 5 ) ) )a '#swq!}} % %a !QYr'rrc:tj|dS)Nr4)rle)rzeros r%rz._gamma_one.._body_fn..sA)=)=r'rrr$)rr while_looprr)rrr,x_keyU_keyrrr^rrrrr9 minus_onerrs r%_body_fnz_gamma_one.._body_fns q'CsACn====y5RVXaJbccGAq! 1 A 1 q!!Ar'''A 1a<r'r4rrr$)rrr9rrrrdivr=rrrrrrrpow)r,r log_spaceone_over_three boost_mask alpha_origrrrrr log_samples log_boostsamplesboostrrr9rrrrrs @@@@@@@@r% _gamma_onerssX 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")rrandom_gamma_grad)rsamples r%rz_gamma_grad..ss'.sT!2r')rLrrry lax_internal_constrrr9tinyreqrr get_backendplatformmaprrFrG) 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')rLrGr&r'rEflattenrrrrthreefry_prng_implrrrrr) 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 |Sr"rr)r,rrs r%rrsQr'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 NrGr9 rJrrr8rFrr?rr r_gammar,rrGr9rs 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. rxrNTrGr9rrrs r%rxrx"s> :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) rFrGrrrrLrwrr)r,rrGr9rs r%rrLs ] HQKKEE%!--- q%((!Xa[[E E""A   S!y  9 99r')r4rrcfd}fd}tjd|}tjdtj}tj||d|||fd} | dz |S)Nc|\}}}}t|\}}tj| k|dz|}t|tj}|dz|||t j|zfSNr)rrrrrFfloat32rLr) carryrrrnglog_prodrrLlamrGs r%body_fnz_poisson_knuth..body_fn_spAq#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_fnfs5(E!HxA tO " "a)m 44r'rr)rrrFrrr) r,rrGr9r rr k_init log_rate_initrs `` ` r%_poisson_knuthrYs 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>٬ @r4c8|\}}}}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) Nrrmr4gQ?rQ?rg9v?) rrr9absrfloorrlgammar)rrk_outacceptedr,subkey_0subkey_1rLr^ u_shiftedrryraccept1rejectaccept2acceptrrk inv_alpharlog_lamrGv_rs r%rz#_poisson_rejection..body_fn{sN#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_fns,#Auh I??  I ..r'r%Frr) rrr=rr9rLbool_rr)r,rrGr9r rr r rrrrkrr r!s `` ` @@@@@r%_poisson_rejectionr$ps 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&rrrrDrLrrrr$ zeros_like) r,rrGr9 use_knuth lam_knuth lam_rejectionr r1s 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 )rJrrrrrrr9r[rrrr rrFrGrLrwrrrr+)r,rrGr9rrrs 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 ) rJrrr8rFrr?rr r_gumbelr:s r%r,r,s( 8S ) )&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% eU # ##r'c td|tjtjt|||tj|jd  S)Nr,rrf)rrLrrrrr,rGr9s 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)rJrrLrrrGrrFdeleter rrlistinsertargmaxr,r9r expand_dimsr) r,r2rrGr 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 ) rJrrr8rFrr?rr r_laplacer:s 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@rGrrf) rrrLrepsnegrrsignrrrrs r%rArAHs|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 ) rJrrr8rFrr?rr r _logisticr:s r%rFrFPs( :s + +&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% 3u % %%r'c td|t|||tj|jd}t jt j|t jt|d|S)NrFrrfr) rrrLrrrrrrr)r,rGr9rs r%rGrGmsiz5!!! 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 ) rJrrr8rFrr?rr r_pareto)r,rkrGr9rs r%rJrJts6 8S ) )&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E a & &&r'c|tj|}ntd|tj||}t |||}tj||z S)NrJ)rFrGrrrrry)r,rkrGr9es r%rKrKs[ ] 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 ) rJrrr8rFrr?rr r_tr,rNrGr9rs r%rrs6 3 $ $&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% CUE " ""r'c|tj|}n#td|tj|tj||}t |\}}t |||}t|d}tj||}t||||} |tj || z zS)Nrr4) rFrGrrrrr7rrrrLr=) r,rNrGr9key_nkey_grXtwohalf_dfr5s r%rPrPs ] 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 ) rJrrr8rFrr?rr r _chisquarerQs r%rXrXs8 ; , ,&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E CUE * **r'cb|tj|}n#td|tj|tj||}t |d}tj||}t||||}tjtj ||}|S)NrXr4)rrGr9) rFrGrrrrrrxrrLry)r,rNrGr9rUrVlog_gchi2s r%rYrYs ] 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 ) rJrrr8rFrr?rr r_f)r,r]r^rGr9rs 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`) rrrFrGrrrrXrLrwr) r,r]r^rGr9key_dfdkey_dfnchi2_dfnchi2_dfdrdenr`s r%rara9s ]  !"(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)rJrrrr r _rademacherr:s r%ririMsZ, < - -&#q#E***  #E * *%  !% ( (% S% ' ''r'ct|d||}d|zdz |S)Nrmrrr4r)ror)r,rGr9bernoulli_sampless r%rjrjjsDC3e<<<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 ) rJrrr8rFrr?rr r_maxwellr:s r%rnrnps. 9c * *&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% #ue $ $$r'cr|dz}t|||}tj|dS)N)rr1r%r5)r7rLlinalgnorm)r,rGr9norm_rvss r%roros7 $,% 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 ) rJrrr8rFrr?rr r_double_sided_maxwell)r,rtrurGr9rs r%rwrws4 13 7 7&#q#E***  5"+ . .- ,$),, - --  #E * *%  !% ( (% sCu = ==r'c,tjtj|tj|}|s|}||z}t |\}}t |||}t |||} | j|jksJ| |z|z|zS)Nr)rrrFrGrrnri) r,rtrurGr9 params_shapes maxwell_keyrademacher_key maxwell_rvs random_signs r%rxrxs&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 ) rJrrr8rFrr?rr r _weibull_min)r,rurrGr9rs r%rrs4 =# . .&#q#E***  5"+ . ., +#(++ , ,,  #E * *%  !% ( (% c5- > >>r'ct||dd|}tjtj|  d|z |zS)Nrr)r,rGrrr9r)rrLpowerr)r,rurrGr9random_uniforms r%rrsN U1Qe===. CI~o...M0A B BU JJr'rXc 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. 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()rrWr%)r rrJrrrr rr7rLrqqrdiagonalrrr:rrrr9) r,rXrGr9rzqrrs r%rrs2  !% ( (% < - -&#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) r rrJrrrrrri)r,r rGr9rr}r5rs 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)r rrJrrrr rrrrrLrr) r,rr rGr9rrrr5rMs 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 ) rJrrr8rFrr?rr r _rayleigh)r,rurGr9rs r%rr`s8 :s + +&#q#E***  5"+ . ., +#(++ , ,,  #E * *%   #E * *E 3ue , ,,r'c|tj|}n#td|tj|t|||}||}t j||}tj|}t|d}tj tj ||}tj ||}|S)NrrW) rFrGrrrrLrwrrrr=r) r,rurGr9rLlog_un_twosqrt_urays r%rrs ] 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 ) rJrrr8rFrr?rr r_wald)r,rMrGr9rs r%rrs: 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)Nrr4r)rFrGrrrrLrwr7rr integer_powr=rr)r,rMrGr9rrr^ryy_sqmean_sq sqrt_termrr]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 ) rJrrr8rFrr?rr r _geometric)r,r rGr9rs 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)rFrGrrrrr9rrrrLrwrrr)r,r rGr9rLrlog_one_minus_pr5s 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 ) rJrrr8rFr8r?rr r _lognormal)r,rrGr9rs r%rrD s2 ; , ,&#q#E***  5"* - -% $!$$ % %%  #E * *%   #E * *E Cu - --r'c|tj|}n#td|tj|tj||}t ||||z}t j|S)Nr)rFrGrrLrwr7rry)r,rrGr9 scaled_norms r%rrg 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?)rLrr9rclamprrint32)rstirling_tail_valsuse_tail_valueskp1sqapproxs r%_stirling_approx_tailrr 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)rrrrr9rLrr) rrnum_geomgeom_sumr,r num_geom_outrLgeomcount log1minusprobprobrGs r%rz$_binomial_inversion..body_fn s!&Ax3**KFC:h%/AxHHLtz**A 8CGAJJ. / /D$H q5,# --r'cb|d|d}}|k|kzSNrr4r)rrrrr s r%r z$_binomial_inversion..cond_fn s4(E!HxA   " " $ $I 66r'rr) r enable_checksr>rLr8r9rrrrrr) r,rrrGr9r rr  num_geom_init geom_sum_initrrrs ``` ` @r%_binomial_inversionr s 4 >$*cl 3 333 3)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?rmgq= ף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)Nrrmrr4rr) rrr9rLrrrrrr)rrrrr,rrrLr^usrrrubrrrrrkrrmrrrGr!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) rLr=rrrr9fullr#rr)r,rrrGr9r stddevrr r rrrrkrrrr!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)Nbinomialrmrrrg$@g@)rLrrGrrFrrrr9rwrr&isinfrrrDrrrrnanrjr)r,rrrGr9 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}) rJrrrr8rFrr?rr rr)r,rXr rGr9rs r%rr sD :s + +&#q*a####E***  5"+ . . I    #E * *%   #E * *E 31eU + ++r' random_clonec|Sr"rrr$s r%rrB s1r'c|gSr"rr)rrs r%rrD 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%clonerF s   S ! !!r')rrr r)r*r+r,rr)r-r r.)r,rrPrQrGrRr r)rsrtr r\)rr+rrrsrtr r)rrr1rtr r)r,rrrr r)r,rrrr r)r,rrrr r)r}rr r\)r}rr r)r}rr r)r}rr r)r}rr r)rrr1rt)r*r+rGrRr r)rrN)r,rrGrRr9rr r) r,rrGrRr9rrrrrr r)r r) r,rrGrRrrrrr9rr r)rF) r,rrrrrQrr-r r)rrTNr)r,rrrrGrRrr-r r!rrQr r)r,rrGrRr9rr r)NNr )r,rrMrrNrrGrOr9rPrQr+r r) r,rr`rrarrGrOr9rr r)r,rr rrGrOr r) r,rrrrkrrGrOr9rr r) r,rrrrGrOr9rr r)r,rr r) r,rrrrGrOr9rr r)F) r,rrrrGrOr9rr r)r%N) r,rr2rrrQrGrOr r) r,rrkrrGrOr9rr r) r,rrNrrGrRr9rr r) r,rrNrrGrOr9rr r) r,rr]rr^rrGrOr9rr r)r,rrGrRr9rr r) r,rrtrrurrGrRr9rr r) r,rrurrrrGrRr9rr r) r,rrXrQrGrRr9rr r) r,rr rrGrRr9rr r) r,rrrQr rrGrRr9r) r,rrurrGrOr9rr r) r,rrMrrGrOr9rr r) r,rr rrGrOr9rr r)r,rrrrrrrrGrOr9rr r) r,rrrrGrOr9rr r) r,rrXrr rrGrOr9rr r) __future__rcollections.abcr functoolsrr&operatorrrrr@numpyrF jax.numpyrLjaxrjax.numpy.linalgr r r jax._srcr r rrrr jax._src.apirrjax._src.interpretersrrr jax._src.laxrjax._src.numpy.lax_numpyrjax._src.numpy.utilrrrjax._src.typingrrr jax._src.utilrrrr DTypeLikeUIntrrQrRr\rrrr&rJrOrUr<rZr+ PRNGSpecDescrrr,rrrrrrrrrrrrrrrrrrr r#r7r9r?rSrTrcrdrrorprtrurrrrrrrrrrr Primitiverdef_impldef_abstract_evaldefjvp2register_lowering lower_funprimitive_batchersrrxrrr$r+r-r,r/r4r@rArFrGrJrKrrPrXrYr`rarirjrnrorwrxrrrrrrrrrrrrrrrrrrrrr simple_impl defvectorizedrrrr'r%r s#"""""$$$$$$  0000000000""""""""$$$$$$******&&&&&&,,,,,,>>>>>>SSSSSSSSSS7777777777++++++       =   +0      F;;;AAAA"EEEEEEEE0S(H,- PPPP. + + + +%)!!!!!!*)->>>>>>:----& - - - - - < < < < < BBBB """"/3999999*8888'+-----<$) " " 55555: V$$$%?%?%?%$%?X#& 555554 V$$$;I;I;I%$;I@$)55555> T"""   #" B!% NONONONONOd#($$$$$> V$$$ + + +%$ + V$$$>>>%$>/37;&0 0D0D0D0D0Dd Y'''('F,0-2 (<(<(<(<( V$$$>>>%$>%)&++.+.+.+.+.Z V$$$)))%$)">>>> "(-)))))> V$$$(((%$(A)A)A)A)H$$$(05'''''";;; // $$$ !6!6777  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 !O!O!O!O!OL !!!!!L EEEEEF$(%*$-$-$-$-$-L V$$$    %$  $!&%(%(%(%(%(N V$$$   %$ (%)$'#*#*#*#*#*J V$$$   %$ &&*', ,;,;,;,;,;\ VD111   21 $",A$(&+!.!.!.!.!.F VD11121OOO0 Yt444544 Yt444,B,B54,B^ VD111777217|! ,,,,,,,,,,` //^$$$ ---~&&&~'7'7888"""""r'