vh 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)ddl*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1ddl2m3Z3m4Z4m5Z5ddl6m7Z7e4Z8e4Z9e5Z:e5Z;e5Zej~Z?ejZ@e%jZBddZCdd ddZDdZEdd ZFd!ZGGd"d#ZHe eIeHe?fZJdd$ZK dd%ZLdd& dd'ZMdd& dd(ZNdd)ZOdBdd+ZPdBdd,ZQdd-ZRdd.ZSdd/ZTdd0ZUdd1ZVdd& dd2ZWdd3ZXd4ZY ddd6 dd7ZZd5e[d8d9fdd6 dd:Z\eed;<dd=Z]e=fdd6 dd>Z^eed;<dd?Z_ ddd6 dd@Z`dAZaeedB<ddCZb d ddFZcd5e[fdd6 ddGZdeedH<ddIZeeedH<ddJZf d ddKZgeedL<ddMZhde[fdd6 ddNZieed;<ddOZje jdPddQf ddRZleeddEgSddTZmde[f ddUZnddVZod5e[f ddWZpeedH<ddXZqde[f ddYZreedZ<dd[Zsd5e[f dd\ZteedH<dd]Zudd^Zvd_Zwdd`daZxdbZyejdcZ{e{jexe{jdde!je{ddee#je{e#jeexdD`dfe#je{e#jeexdD`dfdgheye"je{<de[f ddiZde[f ddjZeedkSdddlZeedm<ddnZeedm<ddoZeedZ<ddpZde=f ddqZd5e[df ddrZeeds<ddtZ d dduZd5e[f ddvZeedH<ddwZd5e[f ddxZeedH<dyZde[f ddzZeedZ<dd{Zd5e[f dd|ZeedZ<dd}Zde[f dd~ZeedZ<ddZde[f ddZeed;<ddZd5e=f ddZeedH<ddZd5e[f ddZeedH<ddZd5e[f ddZeed;<ddZd5e[f ddZeed;<ddZd5e[df ddZd5e[f ddZd*d5e[f ddZde[f ddZeedZ<ddZde[f ddZeedZ<ddZde=f ddZeedZ<ddZde[f ddZeeddDddZe jdde[f ddZeedZdDddZdZeedLdDdZeedLdDdZeed;dDddZde[f ddZejdZejfeejde"jhee#jedde[dd ddZdZy)) annotations)Sequence)partialN)index)Union)lax)choleskysvdeigh)config)core)dispatch)dtypes)prng) xla_bridge)jitvmap)ad)batching)mlir)softmax)_convert_and_clip_integer) _arraylikecheck_arraylikepromote_dtypes_inexact) auto_axes)canonicalize_sharding)Array ArrayLike DTypeLike)canonicalize_axisc.tj||SN)rnexs J/opt/face_recognition/venv/lib/python3.12/site-packages/jax/_src/random.py_isnanr(Es 1F allow_batchedct|tr3tj|jtj r|}d}nt |rtj|t}d}tjjdk(r tdtjjdk(rtjddnLtj jr2tjd t"nt%d t'||s0|j(r$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 ValueErrorwarningsr0enable_custom_prng FutureWarning TypeErrortypendimnpshape)namekeyr+ wrapped_keywrappeds r'_check_prng_keyrIIs$U 1 1#))V__ MKG#""3->-@AKG ##w.  9 ::    % % /mm 9EFH  " " ( (mm 5  /S {; << [-- v!xx}o-OQ RR g r)ctj|jtjsJt j jr|S|rtj|S|Sr#) jnpr5r6rr7r r>r;r random_unwrap) was_wrappedrFs r'_return_prng_keysrNlsJ  6?? 33 3 $$ J&14  c ":s:r)rDctj|jtjsJt j |||S)N bit_widthrD)rKr5r6rr7r random_bits)rFrQrDs r' _random_bitsrSus3  6?? 33 3  #% @@r)ctjj}|tjvsJ|tj|S)zGet the default PRNG implementation. The default implementation is determined by ``config.jax_default_prng_impl``, which specifies it by name. )r r9r;rprngs) impl_names r'r9r9|s; &&,,) djj +)+ I r)cHeZdZUdZdgZded<dZd dZd dZd dZ d dZ y ) PRNGSpecz$Specifies a PRNG key implementation._implPRNGImplc||_yr#)rY)selfr.s r'__init__zPRNGSpec.__init__s DJr)c6d|jjdS)Nz PRNGSpec())rYrEr\s r'__repr__zPRNGSpec.__repr__s tzz) ++r)c,t|jSr#)strrYr`s r'__str__zPRNGSpec.__str__s tzz?r)c,t|jSr#)hashrYr`s r'__hash__zPRNGSpec.__hash__s  r)cXt|txr|j|jk(Sr#)r4rXrY)r\others r'__eq__zPRNGSpec.__eq__s! eX & D4::+DDr)N)returnrc)rkint)rkbool) __name__ __module__ __qualname____doc__ __slots____annotations__r]rardrgrjr)r'rXrXs+,i) /,Er)rXc| tSt|tur|St|tur |jSt|t urk|t jvrt j|Sdjdt jjD}td|d|dt|}td|d)Nz, c3(K|] }d|d yw)"Nrt).0ss r' z$resolve_prng_impl..s=a1QCq=sz"unrecognized PRNG implementation "z". Did you mean one of: ?zunrecognized type z$ for specifying PRNG implementation.) r9rArZrXrYrcrrUjoinkeysr<r@) impl_speckeys_fmtts r'resolve_prng_implrs   )_  )_ ?? )_DJJ ZZ ""yy=4::??+<==H 9)E--5Ja9 :: 9o!&qc)MNOOr)cHt|}t|dr`_ section. When possible, :func:`jax.random.key` is recommended for use instead. The resulting key does not carry a PRNG implementation. The returned key matches the implementation given by the optional ``impl`` argument or, otherwise, determined by the ``jax_default_prng_impl`` config flag. Callers must ensure that same implementation is set as the default when passing this key as an argument to other functions (such as ``jax.random.split`` and ``jax.random.normal``). Args: seed: a 64- or 32-bit integer used as the value of the key. impl: optional string specifying the PRNG implementation (e.g. ``'threefry2x32'``) Returns: A PRNG key, consumable by random functions as well as ``split`` and ``fold_in``. TPRNGKey)rNrrs r'rrs4 4it!< ==r)ctd|\}}tj|r"tdtj|dt j |tj|}t||S)acFolds in data to a PRNG key to form a new PRNG key. Args: key: a PRNG key (from ``key``, ``split``, ``fold_in``). data: a 32-bit integer representing data to be folded into the key. Returns: A new PRNG key that is a deterministic function of the inputs and is statistically safe for producing a stream of new pseudo-random values. fold_inz9fold_in accepts a scalar, but was given an array ofshape r3) rIrCrBr@rDrrandom_fold_inrKuint32rN)rFdatarHkey_outs r'rrsr!C0,#wWWT] XXd^,,NP QQ   SZZ%5 6' 7G ,,r)r1ctj|jtjsJ|j rt d|jdt|tr t|n|f}tj||S)Nz?split accepts a single key, but was given a key array of shape r3rD) rKr5r6rr7rBr@rDr4rtupler random_split)rFnumrDs r'_splitrsv  6?? 33 3XX  YYK'IK LL"31%*v%  3e ,,r)cLtd|\}}t|t||S)aKSplits a PRNG key into `num` new keys by adding a leading axis. Args: key: a PRNG key (from ``key``, ``split``, ``fold_in``). num: optional, a positive integer (or tuple of integers) indicating the number (or shape) of keys to produce. Defaults to 2. Returns: An array-like object of `num` new PRNG keys. split)rIrNr)rFr typed_keyrHs r'rrs)'w4)W 7F9c$: ;;r)ctj|jtjsJt j tj|j}|jSr#) rKr5r6rr7typingcastrKeyTyrY)r} keys_dtypes r' _key_implr)sB  FOO 44 4{{4::tzz2*   r)c~t|}|jtjvr |jSt |Sr#)rrErrUrX)r}r.s r' _key_specr.s- 4$ii4::-A8D>Ar)c:td|d\}}t|S)Nkey_implTr*)rIr)r} typed_keys_s r'rr2s!*d$G-*a : r)ctj|jtjsJt j |Sr#)rKr5r6rr7rrL)r}s r' _key_datar7s/  FOO 44 4  D !!r)c:td|d\}}t|S)z9Recover the bits of key data underlying a PRNG key array.key_dataTr*)rIr)r}rs r'rr;s JD A'$ 4r)cFt|}tj||S)aWrap an array of key data bits into a PRNG key array. Args: key_bits_array: a ``uint32`` array with trailing shape corresponding to the key shape of the PRNG implementation specified by ``impl``. impl: optional, specifies a PRNG implementation, as in ``random.key``. Returns: A PRNG key array, whose dtype is a subdtype of ``jax.dtypes.prng_key`` corresponding to ``impl``, and whose shape equals the leading shape of ``key_bits_array.shape`` up to the key bit dimensions. r-)rrr8)key_bits_arrayr.impl_objs r' wrap_key_datarAs!t $(  .x 88r)c||r:tj|g|}||k7rd}t|j|||yy)Nz{} parameter shapes must be broadcast-compatible with shape argument, and the result of broadcasting the shapes must equal the shape argument, but got result {} for shape argument {}.)rbroadcast_shapesr<format)rErD param_shapesshape_msgs r' _check_shaperVsM  ! !% 7, 7F Lc szz$6 77 r)c <t|fi|}||St||S)N out_sharding)rr)fr hoist_kwargsf_s r'maybe_auto_axesr`s)q!L!" I Rl 33r)rtrctd|\}}|$tjtj}ntj |tj |tjstd|tj|}tj|}t|d}|jdz}tt||||S)aSample uniform bits in the form of unsigned integers. Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default ``()``. dtype: optional, an unsigned integer dtype for the returned values (default ``uint64`` if ``jax_enable_x64`` is true, otherwise ``uint32``). Returns: A random array with the specified shape and dtype. bitsz @@r)?cPtd|\}}tj|tj|}t |d}tj |tjstd|tj|}tt||||||S)aSample uniform random values in [minval, maxval) with given shape/dtype. 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). minval: optional, a minimum (inclusive) value broadcast-compatible with shape for the range (default 0). maxval: optional, a maximum (exclusive) value broadcast-compatible with shape for the range (default 1). Returns: A random array with the specified shape and dtype. uniformz7dtype argument to `uniform` must be a float dtype, got rDr6) rIrrr rrr5rCfloatingr<rr_uniform)rFrDr6minvalmaxvalrrs r'rrs* 9c *&#q##E*  ! !% (%&|Y?,   5"++ . !7$ %%  # #E *% 2<$5 225vv GGr)))static_argnumsc td|tj|tjs t dt j||}t j||}t j|t|}t j|t|}tj|}|j|j}}|dvrt d|d|}|dkrd}t|||} t|} ||k7rt j| | } t jt j | tj"||z | tj"d|j%| } t j&| |tj"d|z } t j(|t j*| ||z z|z|S)Nrz+uniform only accepts floating point dtypes.r @z7uniform only accepts 8-, 16-, 32-, or 64-bit dtypesgot .rr)rrKr5rCrr@rconvert_element_typebroadcast_to_ranklenfinfornmantrS UINT_DTYPES bitwise_orshift_right_logicalarrayviewbitcast_convert_typemaxreshape) rFrrrDr6rnbitsrrng_bitsr uint_dtype float_bitsfloatss r'rrsy% r{{ + A BB  # #FE 2&  # #FE 2&  U 4&  U 4& ))E %U[[% /!  A%J ( QYH c8U +$5!*   # #D* 5D ~~ dBHHX-=z$JKhhsE +*  # #J 6"e9L L&   kk&FVO,v5u= ??r)ctd|\}}tj|tj|}t j |}t |d}tt||||||S)apSample uniform random values in [minval, maxval) with given shape/dtype. Args: key: a PRNG key used as the random key. shape: a tuple of nonnegative integers representing the shape. minval: int or array of ints broadcast-compatible with ``shape``, a minimum (inclusive) value for the range. maxval: int or array of ints broadcast-compatible with ``shape``, a maximum (exclusive) value for the range. dtype: optional, an int dtype for the returned values (default int64 if jax_enable_x64 is true, otherwise int32). Returns: A random array with the specified shape and dtype. randintr) rIrrrr rrr_randint)rFrDrrr6rrs r'rrso, 9c *&#q##E*  # #E *%  ! !% (%&|Y?, Jz_randint..sl3u5r)r1)rrCrDrKr5integerr@rasarrayr6astyperlrgtrriinforrrrrrrselect full_likeadd _lax_constremmul)rFrrrDr6maxval_out_of_rangek1k2rbits higher_bits lower_bitsunsigned_dtypespan multiplier random_offsetrs ` @r'rrsy%&!1288F3CD rzz * ?wG HH)VV, ;;v & ;;v &  bjj 1 ]]3 F  bjj 1 ]]3 F %cii %0@0D0De&Lfll [] %VU 3& $VU 3&  U 4&  U 4& ))E   % /! OPUwW XX #;&"b 5%!"IuRyz+u%. ! !&6/> B$ Ff$cmmD!&.KsxSZZ]D'Ir))r  independent)rIrr!rCrBrr5rr6rr@r concrete_or_errorrlr _permutation)rFr&r r rrr s ` @r'rr0s& =# .&#q-# 4q 1$&|]C,  ==1rzz 2 F GG sA'OPA )?I' )), .. FLt FFI1 NNr)c|stj|dk(r t|||St|tj|j |d}tj |||dS)NrrT)unique_indices)rCrBr rKr rDtake)rFr&r r inds r'rrPsVBGGAJ!O CD !!cjj/3# !S$t 44r)r1c ,d}tjtjj}t j |jstd|jttj|tjt d|jztj|z }t|D]A}t|\}}t|d|j}t!j"|||\}}C|S)NrzSshape polymorphism for `permutation` or `shuffle` for arrays of non-constant size: rr)rKrrCrrr is_constant_dimsizeNotImplementedErrorrlceillograngerrSrDr sort_key_val) rFr&r exponent uint32max num_roundsrsubkey sort_keyss r'r r Ws (ii "&&)  aff %  --.VVH 6 772778bffSAFF^&<>Y C8 ,chh!ms#sD)Afd ~$g'88f3CHHMsDI&QfHa #A &FE {{xk!   %;H:Q H IIzz% f *GCfllCC Da   VQ ' . .s 3c xk4 @3775> Qa IIa7 #A & - -c 2cHHMSsxxS$'?F Q OO !D)E%L8399T!VW;MM OOr)cLtd|\}}tj|}t|d}t j |t j |tjstd|t j|}tt||||S)aYSample standard normal random values with given shape and float dtype. The values are returned according to the probability density function: .. math:: f(x) = \frac{1}{\sqrt{2\pi}}e^{-x^2/2} on the domain :math:`-\infty < x < \infty` Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified shape and dtype. normalzAdtype argument to `normal` must be a float or complex dtype, got r) rIr rrrrr5rCinexactr<rr_normal)rFrDr6rrs r'r<r<s0 8S )&#q  ! !% (%&|X>,##E*   5"** - !7$ %%  # #E *% I,e5 I# NNr))rr1ctj|tjrtjtj d|}t |\}}tjd|jj}t|||j|}t|||j|}|d|zz|z St|||S)Nr1ry?) rr5rCcomplexfloatingrsqrtrrealr6 _normal_realr) rFrDr6sqrt2key_rekey_im real_dtype_re_ims r'r>r>s ub001 HHRWWQZ 'EC[NFF!U#((..J vuj 1 8 8 ?C vuj 1 8 8 ?C "s(Ne ## UE **r)ctd|tjtjd|tjd||}tjd|}t |||||}t j tjtjd|t j|S)Nr<rr%rr1) rrC nextafterrrrrrAerf_inv)rFrDr6lohius r'rCrCsx ||BHHS%("((2u*=UK" xxE" c5%R(! "''!*e,ckk!n ==r)cTtd|\}}tj|t||\}}|dvr t d| |j }tj |tjst d||tj|}t||||||S)a0Sample multivariate normal random values with given mean and covariance. The values are returned according to the probability density function: .. math:: f(x;\mu, \Sigma) = (2\pi)^{-k/2} \det(\Sigma)^{-1}e^{-\frac{1}{2}(x - \mu)^T \Sigma^{-1} (x - \mu)} where :math:`k` is the dimension, :math:`\mu` is the mean (given by ``mean``) and :math:`\Sigma` is the covariance matrix (given by ``cov``). Args: key: a PRNG key used as the random key. mean: a mean vector of shape ``(..., n)``. cov: a positive definite covariance matrix of shape ``(..., n, n)``. The batch shape ``...`` must be broadcast-compatible with that of ``mean``. shape: optional, a tuple of nonnegative integers specifying the result batch shape; that is, the prefix of the result shape excluding the last axis. Must be broadcast-compatible with ``mean.shape[:-1]`` and ``cov.shape[:-2]``. The default (None) produces a result batch shape by broadcasting together the batch shapes of ``mean`` and ``cov``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). method: optional, a method to compute the factor of ``cov``. Must be one of 'svd', 'eigh', and 'cholesky'. Default 'cholesky'. For singular covariance matrices, use 'svd' or 'eigh'. Returns: A random array with the specified dtype and shape given by ``shape + mean.shape[-1:]`` if ``shape`` is not None, or else ``broadcast_shapes(mean.shape[:-1], cov.shape[:-2]) + mean.shape[-1:]``. multivariate_normal>r r r z1method must be one of {'svd', 'eigh', 'cholesky'}zCdtype argument to `multivariate_normal` must be a float dtype, got ) rIrrrr<r6r5rCrr r_multivariate_normal)rFmeancovrDr6methodrs r'rRrRsH 0# 6&#q##E*$T3/)$ .. H II ] JJE   5"++ . ##('+ ,,   # #E *E c4eUF CCr))rrc>tj|dk\s/d}t|jtj|tj|dk\s/d}t|jtj||jd}tj|dd||fk7r1d}t|j|tj||1t j |jdd|jdd}n(td ||jdd|jdd|d k(r0t|\}} } |tj| d dddfz} n?|d k(r/t|\} } | tj| d dddfz} n t|} t|||jddz|}tjd 5|tj d| |z}ddd|S#1swYSxYw)Nrz@multivariate_normal requires mean.ndim >= 1, got mean.ndim == {}r1z>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}.)nrDr<r .r allowz...ij,...j->...i)rCrBr<rrDrrrr rKrAr r r<r numpy_rank_promotioneinsum)rFrTrUrDr6rVrrZrPryrfactorwvnormal_samplesr6s r'rSrS9s !  LC SZZ . //   JC SZZ - .. jjn!XXc]23Aq6! +C SZZ!288C=Z9 :: ]  CR#))CR. AE5$**Sb/399Sb>B u_CIQ1 !CqL/* *F  #YFQ !CqL/* *F c]F#utzz"#6>. ""7+K CJJ16>J JFK -K -s -HHcT|tj|}td|\}}t|d}t j |t j |tjstd|t j|}tt||||||S)aSample truncated standard normal random values with given shape and dtype. The values are returned according to the probability density function: .. math:: f(x) \propto e^{-x^2/2} on the domain :math:`\rm{lower} < x < \rm{upper}`. Args: key: a PRNG key used as the random key. lower: a float or array of floats representing the lower bound for truncation. Must be broadcast-compatible with ``upper``. upper: a float or array of floats representing the upper bound for truncation. Must be broadcast-compatible with ``lower``. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``lower`` and ``upper``. The default (None) produces a result shape by broadcasting ``lower`` and ``upper``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and shape given by ``shape`` if ``shape`` is not None, or else by broadcasting ``lower`` and ``upper``. Returns values in the open interval ``(lower, upper)``. truncated_normalz@dtype argument to `truncated_normal` must be a float dtype, got r) r rrIrrrr5rCrr<rr_truncated_normal)rFlowerupperrDr6rrs r'rcrcZsB   # #E *E -s 3&#q&|5GH,##E*   5"++ . ##('+ ,,  # #E *% 3*L$E 336u FFr)c |=tjtj|tj|}n4t d|tj|tj|tj tj d|}tj||}tj||}tj||z }tj||z }tj|tjs tdt|||||}|tj|z} tj| tj tj"|tj tj$|tj tj"|tj tj$ |S)Nrcr1z4truncated_normal only accepts floating point dtypes.rrr%)rrrCrDrrrArerfrKr5rr@rrMcliprL stop_gradientinf) rFrerfrDr6rDr0brPouts r'rdrdsT ]  %"((5/ BE#UBHHUORXXe_M ((2771:u %% " "5% 0% " "5% 0% ggeem! ggeem! r{{ + J KK c5%!4!  A#   mmC%%e,bhhrvvU.KL mmC%%e,bhhwe.LM OOr)?lowc|tj|}|dvrtd|dtd|\}}t j t j|}tj|tjsd}t|j|t j||}t||||S)aTSample Bernoulli random values with given shape and mean. The values are distributed according to the probability mass function: .. math:: f(k; p) = p^k(1 - p)^{1 - k} where :math:`k \in \{0, 1\}` and :math:`0 \le p \le 1`. Args: key: a PRNG key used as the random key. p: optional, a float or array of floats for the mean of the random variables. Must be broadcast-compatible with ``shape``. Default 0.5. shape: optional, a tuple of nonnegative integers representing the result shape. Must be broadcast-compatible with ``p.shape``. The default (None) produces a result shape equal to ``p.shape``. mode: optional, "high" or "low" for how many bits to use when sampling. default='low'. Set to "high" for correct sampling at small values of `p`. When sampling in float32, bernoulli samples with mode='low' produce incorrect results for p < ~1E-7. mode="high" approximately doubles the cost of sampling. Returns: A random array with boolean dtype and shape given by ``shape`` if ``shape`` is not None, or else ``p.shape``. highrpz got mode=z, expected 'high' or 'low' bernoulliz=bernoulli probability `p` must have a floating dtype, got {}.r")r rr<rIrrrr6rKr5rCrr@rr _bernoulli)rFr2rDr"rr6rs r'rtrts<   # #E *E  zD7"<= >> ; ,&#q  # #CIIaL 1% r{{ + IC CJJu% && q%(! CE --r))static_argnamescp|tj|}n td|tj|tj|}|dk(rBt |dg||\}}|dt j|j zz}|||z kSt ||tj||kS)Nrtrsr1) rCrDrrr6rrrr)rFr2rDr"r6u1u2s r'rvrvs ] HHQKEeRXXa[1 ))A,% V^ S1+u+u -FB! U#))) ))B B; 3syy| ,q 00r)c$td|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r_beta)rFr0rmrDr6rs r'r|r|s< 63 '&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E sAq% ''r)c|=tjtj|tj|}n4t d|tj|tj|tj ||}tj ||}t |\}}tj||}tj||}t||||}t||||}tj||} tj|| z } tj|| z } | | | zz S)Nr|) rrrCrDrrrrK broadcast_tologgammarexp) rFr0rmrDr6key_akey_b log_gamma_a log_gamma_blog_maxgamma_a_scaledgamma_b_scaleds r'r}r}s ]  !bhhqk :E RXXa[9 q%(! q%(!,% q% ! q% !5%0+5%0+ GGK -'77;01.77;01. >N: ;;r)ctd|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r_cauchyrFrDr6rs r'rrs, 8S )&#q##E*   5"++ . ##('+ ,,  # #E *%  ! !% (% eU ##r)c 6td|t|||tj|jd}t |t j}tjtj|tj|t |dS)Nrrrhro) rrrKrepsrrCpirtanrsub)rFrDr6rPrs r'rr8six c5% %(8(<(= 1, got alpha.ndim == {}r&r) rCrBr<rrDrrrrr)rFrrDr6rlog_gamma_sampless r'rrms 1  DC SZZ/ 00 ] HHUOCR EeRXXe_Sb%9: " "5% 0%sE5288E?233G+GO "B ''r)ctd|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r _exponentialrs r'rrs, =# .&#q##E*   5"++ . ##('+ ,,  # #E *%  ! !% (% c5% ((r)ctd|t|||}tjtjtj|S)Nr)rrrneglog1prFrDr6rPs r'rrs:}e$ c5% ! 3771:& ''r)c t|dt|dt|dt|dt|d}t|dtj|tj|}|}tj||tj |}tj ||tj|tjfd}fd}t|\}}tj|||t|d f\} } } } |rtjt|d  } tj|| dk(ztj| tj|} tj tj tjtj| | Sdt|d  z } tj|tj | tj|}tjtj| |S) Nrrr&rogUUUUUU?gm{?c|\}}}}tjtj|tjtj tj||tjtj |tj tj|tjtj tj|tj |}|Sr#)r bitwise_andgerrrr) kXVUrXVUconddone one_over_two squeeze_consts r'_cond_fnz_gamma_one.._cond_fnsJAq!Q ??366!SWWS#''-QRTU2W%XY66#''!*cggcgga6N69ggaQTVWILQRBU7V/WX YD Kr)c& fd}|d}t|d\}}}tjfd|| f\}}}tj||}tjtj|||} t |d } ||| | fS)Nc|d}t|\}}t|d}tjtj|}|||fS)Nrrtr%)rr<rrr)kxvrFr r&r`cr6rs r' _next_kxvz/_gamma_one.._body_fn.._next_kxvsM Fc3Kkc6 5 )a ''#swwq!} %a !QYr)rrc6tj|dS)Nr1)rle)rzeros r'rz._gamma_one.._body_fn..sA)=r)rtr%)rr while_looprr)rrrFx_keyU_keyrr&r`rrrrr6 minus_onerrs r'_body_fnz_gamma_one.._body_fns q'CsACnn=y5RVXaJbcGAq! 1 A 1 q!Ar'A 1a<r)r1rtr%)rrr6rrrrdivrArrrrrrrpow)rFr log_spaceone_over_three boost_mask alpha_origrrr rr log_samples log_boostsamplesboostrrr6rrrrrs @@@@@@@@r' _gamma_oners E1 $5!##)E3',eW-.UF+- ))E %vveS!** **Zs(; <% gge^$! ggnchhqk*! "s +#v~~h3c:eUVCW2XY*!Q1''+fb>?K :)9:D#''+WZW^W^_bdnWoBpqI 773773771:swwqz2I >>'&"E22G JJz3j9Q(R SE 773771a=% ((r)ctj|d}tj|d}|rtj|}t j |d}tj |tj|jj}tjtj||||}dntjtjjdk(rtj fd||f}nt#||}|jt%j&|S)Nr&rc4tj|||z Sr#)rrandom_gamma_grad)rsamples r'rz_gamma_grad..ss'<'.s T!2r))rKrrr lax_internal_constrrr6tinyreqrr get_backendplatformmaprrCrD) rr0rralphasrrgradsrs @r' _gamma_gradrs KK #' ;;q" &gggG   vq )D ==#))GMM":"?"? @Djj.g>GTJ&&J&&%/ GG2VW4E FE D VW -E rxx{ ##r))use_vmapctj|}tj||jd}|j }t td||}|j }|j }|r=t|tjur"t tt||}ntjfd||f}tj||S)N)rN)in_axesrct|diS)Nr)r)rrs r'rz_gamma_impl.. sZ;;r))rKrDr(r)rBflattenrrrrthreefry_prng_implrrrrr) rFr0rra_shape split_countr}rrs ` r' _gamma_implrs IIaL' '#((),-+ $ (fi ({ ;$ $ 99;& )C.D$;$;;.s'MQamaggajMs !!rr)nextzipr bdim_at_frontrandom_gamma_pbind) batched_args batch_dimsrr'r0bkbars r'_gamma_batching_rulersz $!Q &"b M z:M M$QD)!QD)!   QY  7 ::r) random_gammac |Sr#rt)rFr0rs r'rrsQr)c "|t||fi|zSr#)r)tangentansrFr0kwdss r'rrs;sA3N3N)Nr))multiple_resultsr)rc$td|\}}tj|tj|tj st 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 r rIrrr5rCrr<rr r_gammarFr0rDr6rs r'rr&sH 7C (&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E Qe5 11r)c&td|\}}tj|tj|tj st 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. rrTrDr6rrrs r'rrUs> :s +&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E Qe5D AAr)rc*|tj|}n td|tj|tj||}tj||k7rt j ||}tj|||S)Nrr) rCrDrrrrKrrr)rFr0rDr6rs r'rrst ] HHQKE%!- q%(!XXa[E E"A   S!y  99r))r1rrcfd}fd}tjd|}tjdtj}tj||d|||fd} | dz j |S)Nc|\}}}}t|\}}tj| kD|dz|}t|tj }|dz|||t j|zfSNr)rrrrrCfloat32rKr) carryrr'rnglog_prodr rPlamrDs r'body_fnz_poisson_knuth..body_fnslAq#x+KC 8sd?AE1-Arzz*A q5!S(SWWQZ/ //r)cL|d|d}}| kDj|kzS)Nrrany)rrrr max_iterss r'cond_fnz_poisson_knuth..cond_fns2(E!HxA tO "a)m 44r)rr)rrrCrrr) rFrrDr6r rr k_init log_rate_initr's `` ` r'_poisson_knuthrsn 05 ==a .&--Q E:- nnWg63 'FGJ! 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} | j|S)Ngn?= ףp=@gh|?5g[ m?g$~?gr?g333333 @gr鷯?gB>٬ @r1c(|\}}}}t|d\}}}t|jdz }t|j}dt|z } t j dz| z z|zzdz} t j |z| | zz zz }  | zzt j| dzz } | dk\|kz} | dk| dk|| kDzz}| | k}| ||zz}t j|| |}||z}|dz|||fS) Nrror1gQ?rQ?rg9v?) rrr6absrfloorrlgammar)rrk_outacceptedrFsubkey_0subkey_1rPr` u_shiftedr'ryraccept1rejectaccept2acceptr0rm inv_alpharlog_lamrDv_rs r'rz#_poisson_rejection..body_fnsD#Auh$S!nC8%+c1A%+Ac!f I 1q59$q(A-3d:;A I i)&;!F1fG ') *F JJvq% (E H q5%3 &&r)c@|\}}}}|j|kzSr#r)rrrrrFr s r'r z#_poisson_rejection..cond_fns)#Auh I?? I ..r)r&Frr) rrrArr6rKbool_rr)rFrrDr6r rr r rr'r0rmrr r!s `` ` @@@@@r'_poisson_rejectionr$s GGCL' dSXXc]""! w{!vS)))1q5!!#'',/ ==b#))U 3& ]]3syy% 8( nnWg68S'AB1E! %r)c t||dkz}tj||tj|d}tj|tj|d|}|j t j |j}tj|t|||||t|||||}tj|dk(t j||S)N rgj@r) r(rrrrArKrrrr$ zeros_like) rFrrDr6 use_knuth lam_knuth lam_rejectionr r6s r'_poissonr+sSkS2X&)jjCsC)@A)**Y c3(?E-jj5)--.) :: 3 5%;sM5%C & C1HcnnV4f ==r)ctd|\}}tj|tjt j |j}|j}|t jurtd|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 )rIrrrrrrr6rYrrrr rrCrDrKrrrrr+)rFrrDr6rrrs r'r-r-s2 9c *&#q##E*{{4::syy1*   ( T,,,  j    # #E *%   # #E *E HHSME e$#   bjj1# #sE5 ))r)ctd|\}}tj|tj|tj st d|tj|}tj|}|tjjrdnd}|dvrt d|zt||||S)aSample Gumbel random values with given shape and float dtype. The values are distributed according to the probability density function: .. math:: f(x) = e^{-(x + e^{-x})} Args: key: a PRNG key used as the random key. shape: optional, a tuple of nonnegative integers representing the result shape. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). mode: optional, "high" or "low" for how many bits to use when sampling. The default is determined by the ``use_high_dynamic_range_gumbel`` config, which defaults to "low". When drawing float32 samples, with mode="low" the uniform resolution is such that the largest possible gumbel logit is ~16; with mode="high" this is increased to ~32, at approximately double the computational cost. Returns: A random array with the specified shape and dtype. r.z6dtype argument to `gumbel` must be a float dtype, got rsrprrz*Must provide valid mode for gumbel got: %s)rIrrr5rCrr<rr rr use_high_dynamic_range_gumbelr;_gumbel)rFrDr6r"rs r'r.r.s6 8S )&#q##E*   5"++ . ##('+ ,,  # #E *%  ! !% (% \99??6UD  ADH II eUD ))r))rr1rc td||dk(rt|ddd|z|\}}tj|dk\||dtj|j z|zztj|j z}tjtj|   Stjtjt|tj|j d||  S) Nr.rsrrr)rrrDr6ror1) rrrKwhererrrrr)rFrDr6r"rsrpr&s r'r0r08sx V^R#e|5:ID# $#+t qcii&,,--33cii6F6K6KK MA GGSYYr]N # ## GGSWWSYYu-222E +,, - --r)c td|\}}td|tj|}t t j |j|}||}n"tj|}td|||dt|t|z } |r|dk\r|t|jz}t|t|t|z d} | j|t|jz|j|tjt|g| | |j |t#j$|t t't| z|S|t||j|j |z }t)j*| } | |j|kDrt-d| d|j|dt#j.tj0||d | \}} | j|| fzk(sJ|| |zk(sJ| j2d z gt'| j2d z } t#j4| || } | j|k(sJ| S) aSample random values from categorical distributions. Sampling with replacement uses the Gumbel max trick. Sampling without replacement uses the Gumbel top-k trick. See [1] for reference. Args: key: a PRNG key used as the random key. logits: Unnormalized log probabilities of the categorical distribution(s) to sample from, so that `softmax(logits, axis)` gives the corresponding probabilities. axis: Axis along which logits belong to the same categorical distribution. shape: Optional, a tuple of nonnegative integers representing the result shape. Must be broadcast-compatible with ``np.delete(logits.shape, axis)``. The default (None) produces a result shape equal to ``np.delete(logits.shape, axis)``. replace: If True (default), perform sampling with replacement. If False, perform sampling without replacement. mode: optional, "high" or "low" for how many bits to use in the gumbel sampler. The default is determined by the ``use_high_dynamic_range_gumbel`` config, which defaults to "low". With mode="low", in float32 sampling will be biased for events with probability less than about 1E-7; with mode="high" this limit is pushed down to about 1E-14. mode="high" approximately doubles the cost of sampling. Returns: A random array with int dtype and shape given by ``shape`` if ``shape`` is not None, or else ``np.delete(logits.shape, axis)``. References: .. [1] Wouter Kool, Herke van Hoof, Max Welling. "Stochastic Beams and Where to Find Them: The Gumbel-Top-k Trick for Sampling Sequences Without Replacement". Proceedings of the 36th International Conference on Machine Learning, PMLR 97:3499-3508, 2019. https://proceedings.mlr.press/v97/kool19a.html. categoricalNrrur z'Number of samples without replacement (z&) cannot exceed number of categories (z).r&r)rIrrKrrrCdeleterDr rrrlistinsertargmaxr.r6r expand_dimsrr(r)r<r/moveaxisrBr)rFlogitsr rDr1r"r logits_arr batch_shape shape_prefix logits_shaper'indices dimensionss r'r4r4IsZP =# .&#q-({{6"*bii 0 0$78+ ] E  # #E *E{33E 3{#334,  qy c*""##dc%j3{+;;<=>Ls:#3#344j6F6Ft6LM ::s2l2\2J4D4D4P  E%L0A*B$CD E   &j.. 0@0@tLLJ ,A:  D !!  1!5!''-.b 2  3<< D"=qAJAw ==K1$. .. . L;. .. .,,"=U7<td|t|||dtj|jzd}t j t j|t jt jt j|S)NrDrKrrh) rrrKrepsnegrrsignrrrrs r'rErEsiy%   5%cii&6&=&= =bJ! !cii (;< ==r)ctd|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r _logisticrs r'rJrJs( :s +&#q##E*   5"++ . ##('+ ,,  # #E *%  ! !% (% 3u %%r)c td|t|||tj|jd}t j t j|t jt|d|S)NrJrrhr) rrrKrrrrrrr)rFrDr6r&s r'rKrKsYz5! c5% %(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 ) rIrrr5rCrr<rr r_pareto)rFrmrDr6rs r'rNrNs6 8S )&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E a &&r)c|tj|}n td|tj||}t |||}tj ||z S)NrN)rCrDrrrrr)rFrmrDr6es r'rOrOsP ] HHQKE5! q%(!#ue$! Qr)ctd|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r_trFdfrDr6rs r'rrs6 3 $&#q##E*   5"++ . ##('+ ,,  # #E *%  ! !% (% CUE ""r)cj|tj|}n td|tj|tj||}t |\}}t |||}t|d}tj||}t||||} |tj|| z zS)Nrr1) rCrDrrrrr<rrrrKrA) rFrUrDr6key_nkey_grZtwohalf_dfr:s r'rSrS7s ] HHRLEeRXXb\* E*",% UE5!!1a# GGB ' E7E5)! SXXgk " ""r)c"td|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r _chisquarerTs r'r\r\Gs8 ; ,&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E CUE **r)cV|tj|}n td|tj|tj||}t |d}tj ||}t||||}tjtj||}|S)Nr\r1)r0rDr6) rCrDrrrrrrrrKr)rFrUrDr6rYrZlog_gchi2s r'r]r]ms ] HHRLEeRXXb\2 E*"2q# GGB ' 3'e <%  %$ +r)c$td|\}}tj|tj|tj st 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``. rz1dtype argument to `f` must be a float dtype, got ) rIrrr5rCrr<rr r_f)rFdfnumdfdenrDr6rs r'rr{sD 3 $&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E Cue ,,r)ct|=tjtj|tj|}n4t d|tj|tj|tj ||}tj ||}t |\}}t||||}t||||}tj||}tj||}tj||} tj||} tj| | } | S)Nr) rrrCrDrrrr\rKrr) rFrcrdrDr6key_dfdkey_dfnchi2_dfnchi2_dfdrdenrs r'rbrbs ]  ! !"((5/288E? CEeRXXe_bhhuo> " "5% 0% " "5% 0%C['7 wue 4( wue 4(  5% (%  5% (% % # % # ggc3! (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)rIrrrr r _rademacherrs r'rlrlsQ, < -&#q##E*  # #E *%  ! !% (% S% ''r)cjt|d|j|}d|zdz j|S)Nro)rFr2rDr1r)rtr)rFrDr6bernoulli_sampless r'rmrms8C3e<CCEJ  ! # + +E 22r)ctd|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r_maxwellrs r'rqrqs. 9c *&#q##E*   5"++ . ##('+ ,,  # #E *%  ! !% (% #ue $$r)cj|dz}t|||}tjj|dS)N)r)rFrDr6r&r5)r<rKlinalgnorm)rFrDr6norm_rvss r'rrrrs0 $,% 5 6(  ++r)c td|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r_double_sided_maxwell)rFlocscalerDr6rs r'rxrxs4 13 7&#q##E*   5"++ . $$)7, --  # #E *%  ! !% (% sCu ==r)c,tjtj|tj|}|s|}||z}t |\}}t |||}t |||} | j|jk(sJ| |z|z|zS)Nr)rrrCrDrrqrl) rFrzr{rDr6 params_shapes maxwell_keyrademacher_key maxwell_rvs random_signs r'ryry*s&&rxx}bhhuoF-  E - % &s +~ 5>+>eD+   k// // / { "U *S 00r)c td|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r _weibull_min)rFr{ concentrationrDr6rs r'rr:s4 =# .&#q##E*   5"++ . ##('+ ,,  # #E *%  ! !% (% c5- >>r)ct||dd|}tjtj|  d|z |zS)Nrr)rFrDrrr6r)rrKpowerr)rFr{rrDr6random_uniforms r'rr^sB U1Qe=. CII~o..M0A BU JJr)cV||}n|}tj|}td|\}}tj|t d|tj t|d}tj t|d}t|g|t||t|||}tjj|\}} tjj| } |tjtj | dz} ||kr | j"S| S)aSample uniformly from the orthogonal group O(n). If the dtype is complex, sample uniformly from the unitary group U(n). For unequal rows and columns, this samples a semi-orthogonal matrix instead. That is, if :math:`A` is the resulting matrix and :math:`A^*` is its conjugate transpose, then: - If :math:`n \leq m`, the rows are mutually orthonormal: :math:`A A^* = I_n`. - If :math:`m \leq n`, the columns are mutually orthonormal: :math:`A^* A = I_m`. Args: key: a PRNG key used as the random key. n: an integer indicating the number of rows. shape: optional, the batch dimensions of the result. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). m: an integer indicating the number of columns. Defaults to `n`. Returns: A random array of shape `(*shape, n, m)` and specified dtype. References: .. [1] Mezzadri, Francesco. (2007). "How to generate random matrices from the classical compact groups". Notices of the American Mathematical Society, 54(5), 592-604. https://arxiv.org/abs/math-ph/0609050. orthogonalz-The error occurred in jax.random.orthogonal()rY)r rrIrrrrrr<rminrKrtqrdiagonalr:rHmT) rFrZrDr6m_mrzqr rr&s r'rrgsDY B B  ! !% (% < -&#q##E*|U# UA'VW! eR)XY" S2E23q":2s1bz2E:! q $!Q jj!!#//#((1+r **!V 44K Hr)ctj|}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 rrIrrrrrrl)rFr2rDr6rr}r:r s r'rrs4  ! !% (% / 5&#q##E*#U+ s$ DGQqS%'!a%'! Q1q5\ r)ctj|}td|\}}tj|t d|tj t|d}t|\}}t||g|||}t|||} |tj||zjd| zd|z zdz S)a$Sample uniformly from the unit Lp ball. Reference: https://arxiv.org/abs/math/0503650. Args: key: a PRNG key used as the random key. d: a nonnegative int representing the dimensionality of the ball. p: a float representing the p parameter of the Lp norm. shape: optional, the batch dimensions of the result. Default (). dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array of shape `(*shape, d)` and specified dtype. ballz'The error occurred in jax.random.ball()r&r).N)r rrIrrrrrrrrrKrsum) rFrr2rDr6rrrr:rQs r'rrs,  ! !% (% 63 '&#q##E*vu UA'PQ! :&"bQ %  U3!"eU#!  a$$R(1,!a%8) D DDr)c"td|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r _rayleigh)rFr{rDr6rs r'rrs8 :s +&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E 3ue ,,r)c|tj|}n td|tj|t|||}|j |}t j ||}tj|}t|d}tjtj||}tj||}|S)NrrY) rCrDrrrrKrrrrrAr) rFr{rDr6rPlog_un_twosqrt_urays r'rr s ] HHUOEUBHHUO4 c5% ! ,,u %  5% (% ''!*% UB % 88CGGE5) *& v# *r)c"td|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r_wald)rFrTrDr6rs r'rr s: 63 '&#q##E*   5"++ . ##('+ ,,  # #E *%   # #E *E sD% ''r)cl|tj|}n td|tj|t|d\}}|j |}t j ||}t|||}t|||}tj|d}tj|d} tj|d} tjd|z|z| | zz} || |zdz z|dz | zz } tjtj|||| zz | | | z } | S)Nrr1r)rCrDrrrrKrr<rr integer_powrArr)rFrTrDr6rrr`ryy_sqmean_sq sqrt_termr&r_s r'rr> s ] XXd^E/ #q>&"b U $  $ &$ R! b%! ooa! A $ OOD! $'hhq4x!|gn45) Wq[1_tax)33! jjDD1H-.7Q;?! (r)c"td|\}}tj|tj|tj st 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 ) rIrrr5rCrr<rr r _geometric)rFr2rDr6rs r'rrQ s6 ; ,&#q##E*   5"** - ##('+ ,,  # #E *%   # #E *E CE5 ))r)c|tj|}n td|tj|td|t |\}t |||j }tj|}tj| }tj||}tjtj||dz}|j|S)Nrr)rCrDrrrrr6rrrrKrrrr)rFr2rDr6rPrlog_one_minus_pr:s r'rrv s ] XXa[EeRXXa[1+q!a "! c5!''"! ''!*%IIqbM/$$_e 0`. Args: key: a PRNG key used as the random key. sigma: a float or array of floats broadcast-compatible with ``shape`` representing the standard deviation of the underlying normal distribution. Default 1. shape: optional, a tuple of nonnegative integers specifying the result shape. The default (None) produces a result shape equal to ``()``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``shape``. lognormalzDdtype argument to `lognormal` must be a float or complex dtype, got ) rIrrr5rCr=r<rr r _lognormal)rFsigmarDr6rs r'rr s2 ; ,&#q##E*   5"** - !7$ %%  # #E *%   # #E *E Cu --r)c|tj|}n td|tj|tj||}t ||||z}t j|S)Nr)rCrDrrKrr<rr)rFrrDr6 scaled_norms r'rr s\ ] XXe_Eubhhuo6  5% (%sE5)E1+  r)cjtjgd|j}|dk}tjt |d|t |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?) rKrr6rclamprrrint32)r'stirling_tail_valsuse_tail_valueskp1sqapproxs r'_stirling_approx_tailr syy  GGF/ ii 1c"Az!S'9:! q5QU %  J$66%? ?AE J& iil! O%7 ! %Ev NNr)c tjjr0tjj tj sJtj   fd}fd}tjdj }tjdj } d|| |f} tj||| d} | dz j|S)Nc|\}}}}t|\}}tj| k|dz|}t| j}t j t j| z }||z}|dz|||fSr)rrrrr6rKrr) rrnum_geomgeom_sumrFr  num_geom_outrPgeomcount log1minusprobprobrDs r'rz$_binomial_inversion..body_fn s!&Ax3*KFC::h%/AxHLtzz*A 88CGGAJ. /D$H q5,# --r)cJ|d|d}}|kj|kzSNrr1r)rrrrr s r'r z$_binomial_inversion..cond_fn s1(E!HxA   " " $I 66r)rr) r enable_checksr;rKr5r6rrrrrr) rFrrrDr6r rr  num_geom_init geom_sum_initrr'rs ``` ` @r'_binomial_inversionr s  >>$**cll 33 3))TE"-.7--aU;---aU;- m]C 0% nnWgu-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| tj dtj|f} tj||| dj|S)Nrgffffff?rgEJYga+e?{Gz?rogq= ףp?g@gp= ף@gffffff@cV |\}}}}t|d\}}}t|j}t|j}|dz }dtj|z } | dk\|kz} tj dz| z z|zz} | dk| kDz} tj |z| | zz zz }dztj dzz dzzz zdztj z dz| z dzz zz| dztj | z dzz| dzz zztztz zt| z t| z z } || k}| | |zz}tj|| |}||z}|dz|||fS)Nrrorr1rr) rrr6rKrrrrrr)rrrrrFrrrPr`usrr'rubrrr0rrmrrrrr rDr!s r'rz_btrs..body_fn4 s#Auh#CmC8%,A%,A CA swwqz BTza3h'G 1q52:>Q&*+A!eE "F E Q"r']Q./0A3w#''1q5Q%!)a-%89:: cgguqy1}Q?@@A SCGGAQ/1q59::; a ! eai( ) a ! eai( )2gG ') *F JJvq% (E H q5%3 &&r)cF|d|d}}|j|kzSrr)rrrr s r'r z_btrs..cond_fnN s,(E!HxA I?? I ..r)r&rF) rKrArrrr6fullr#rr)rFrrrDr6r stddevrr r rr0rrmrrr r!s ``` ` @@@@@@@r'_btrsr' s 88EDLAH- .& TF]!  TD[(! dlS! sQw# a$h! #'>V #% iid"#!''4/ ==r4::u 5& fchhueSYY7 =% % 0 3 : :5 AAr)c  |=tjtj|tj|}n4td|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|}|jtj |j"}t j| t%|| ||||t'|| ||||}| | z|z}t j|tj|tj(||}t j||ztj|tj*||}t j||z| z|z||j-||z }|S)Nbinomialrorrrg$@g@)rKrrDrrCrrrr6rrr(isinfrrrArrrrnanrlr)rFrrrDr6 p_lt_halfrcount_nan_or_neg count_infq_is_nanq_l_0 use_inversion count_inv count_btrsq_btrsr rinvalids r' _binomialrW sy  ]  5!1399T? CEUBHHUORXXd^D "4 ('4 " "5$** 5%  5% (%  $ &$Sj) jjD#*-!E]eck2ii) AY( c'% jjE!3==D#91=!"eai4&78- ))E %jjs}}UC/HI)zz-uc)BEJ* ::mS]]1c%:A >&jj5)--.) JJY5%C #z65%; 'X  0 0' JJ MM'377E*  ' JJ 'MM'377E*  ' JJ   8+i7  LL'! ' .r)c>td|\}}td||tj|tj|t j std|tj|}|tj|}t|||||S)aSample Binomial random values with given shape and float dtype. The values are returned according to the probability mass function: .. math:: f(k;n,p) = \binom{n}{k}p^k(1-p)^{n-k} on the domain :math:`0 < p < 1`, and where :math:`n` is a nonnegative integer representing the number of trials and :math:`p` is a float representing the probability of success of an individual trial. Args: key: a PRNG key used as the random key. n: a float or array of floats broadcast-compatible with ``shape`` representing the number of trials. p: a float or array of floats broadcast-compatible with ``shape`` representing the probability of success of an individual trial. shape: optional, a tuple of nonnegative integers specifying the result shape. Must be broadcast-compatible with ``n`` and ``p``. The default (None) produces a result shape equal to ``np.broadcast(n, p).shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). Returns: A random array with the specified dtype and with shape given by ``np.broadcast(n, p).shape``. rz8dtype argument to `binomial` must be a float dtype, got ) rIrrrr5rCrr<rr rr)rFrZr2rDr6rs r'rr sD :s +&#q*a###E*   5"++ .  B5'J   # #E *%   # #E *E 31eU ++r) random_clonec|Sr#rtr%s r'rr s1r)c|gSr#rt)rr's r'rr sQCr))rDr6unrollc*td|\}}td||t||\}}| |j}t j ||dd}t j ||}d}t j |dd}tj|dd}|t j|dk(d|z } t|| jd} tj||| | f| \} } t j | ddj|S) aSample from a multinomial distribution. The probability mass function is .. math:: f(x;n,p) = \frac{n!}{x_1! \ldots x_k!} p_1^{x_1} \ldots p_k^{x_k} Args: key: PRNG key. n: number of trials. Should have shape broadcastable to ``p.shape[:-1]``. p: probability of each outcome, with outcomes along the last axis. shape: optional, a tuple of nonnegative integers specifying the result batch shape, that is, the prefix of the result shape excluding the last axis. Must be broadcast-compatible with ``p.shape[:-1]``. The default (None) produces a result shape equal to ``p.shape``. dtype: optional, a float dtype for the returned values (default float64 if jax_enable_x64 is true, otherwise float32). unroll: optional, unroll parameter passed to :func:`jax.lax.scan` inside the implementation of this function. Returns: An array of counts for each outcome with the specified dtype and with shape ``p.shape`` if ``shape`` is None, otherwise ``shape + (p.shape[-1],)``. multinomialNr&cl|\}}t|||jdd|j}||z |fS)Nrrr%)rrjr6) remainder ratio_keyratiorFrs r'rzmultinomial..f s:JE3 S)UZZ1%5Y__ ME u e ##r)rT)reverser)r) rIrrrDrKrr;rr,r2rscanr) rFrZr2rDr6rrrremaining_probsratiosr}rcountss r'rr sD =# .&#q-A& 1 %$!Q ] GGE q%*%! q% !$  ll1b!!JJq!T2/ syyA-q/B B& sFLLO $$hhq!fd^FC)V fa $ + +E 22r)c,tj|S)a}Clone a key for reuse Outside the context of key reuse checking (see :mod:`jax.experimental.key_reuse`) this function operates as an identity. Examples: >>> import jax >>> key = jax.random.key(0) >>> data = jax.random.uniform(key) >>> cloned_key = jax.random.clone(key) >>> same_data = jax.random.uniform(cloned_key) >>> assert data == same_data )random_clone_pr)rFs r'cloner s   S !!r))r&rrkr)rErcrFrr+rmrkztuple[Array, bool])rFrrQrlrDShaperkr)r~PRNGSpecDesc | NonerkrZ)rrcrint | ArrayLiker~rrkr)rrr.rrkr)rFrr IntegerArrayrkr)rFrrint | tuple[int, ...]rkr)rFrrrrkr)r}rrkrZ)r}rrkstr | PRNGSpec)r}rrkr)r}rrkr)r}rrkr)rrr.r)rErcrDrrkNone)rtN)rFrrDrr6zDTypeLikeUInt | Nonerkr) rFrrDrr6DTypeLikeFloatr RealArrayrr rkr)rkr) rFrrDrrrrrr6 DTypeLikeIntrkr)rF) rFrr&rr rlr rmrkr)rtTNrN)rFrr0rrDrr1rmr2zRealArray | Noner rlr" str | Nonerkr)rFrrDrr6r rkr)NNr )rFrrTr rUr rD Shape | Noner6zDTypeLikeFloat | NonerVrcrkr) rFrrer rfr rDr r6r rkr) rFrr2r rDr r"rcrkr) rFrr2rrDr r"rcrkr) rFrr0r rmr rDr r6r rkr) rFrrr rDr r6r rkr)rFrrkr) rFrr0r rDr r6r rkr)F) rFrrr rDr r6r rkr) rFrrDrr6r r"r rkr)r&NTN)rFrr<r r rlrDr r1rmr"r rkr) rFrrmr rDr r6r rkr) rFrrUr rDrr6r rkr) rFrrUr rDr r6r rkr) rFrrcr rdr rDr r6r rkr)rFrrDrr6r rkr) rFrrzr r{r rDrr6r rkr) rFrr{r rr rDrr6r rkr) rFrrZrlrDrr6r rz int | Nonerkr) rFrr2floatrDrr6r rkr) rFrrrlr2rrDrr6r ) rFrr{r rDr r6r rkr) rFrrTr rDr r6r rkr) rFrr2r rDr r6r rkr)rFrrr r"r rr rDr r6r rkr) rFrrr rDr r6r rkr) rFrrZr r2r rDr r6r rkr) rFrrZr r2r rDr r6r rz int | bool) __future__rcollections.abcr functoolsrr(operatorrrrr=numpyrC jax.numpyrKjaxrjax.numpy.linalgr r r jax._srcr r rrrr jax._src.apirrjax._src.interpretersrrr jax._src.laxrjax._src.nn.functionsrjax._src.numpy.lax_numpyrjax._src.numpy.utilrrr jax._src.pjitrjax._src.sharding_implsrjax._src.typingrrr jax._src.utilr!r rr  DTypeLikeUIntr rlrrZrrrr(rIrNrSr9rXrc PRNGSpecDescrrrFrrrrrrrrrrrrrrrrrrrrr r$r<r>rCrRrSrcrdrrtrvr|r}rrrrrrrrrr Primitiverdef_impldef_abstract_evaldefjvp2register_lowering lower_funprimitive_batchersrrrrr$r+r-r.r0r4rDrErJrKrNrOrrSr\r]rrbrlrmrqrrrxryrrrrrrrrrrrrrrrrrrrrr simple_impl defvectorizedrrrtr)r'r-sH#$  00"$*&,)>SS#977+       ==   +0 #' 4F F;A"EE0S(H,- P. +' +,1 +%)!!!-2!*)->%>16>:-& - < B "/39+9*84'+@ @@$@ % @D$) " " G  GG!GG G #( GB V$%?%%?X#&    !  #( < V$;I%;I@$)N " N"NN"N ', N@5 T" # B!%" UOUOUOUO UO  UO  UO (- UOr#( O O O  O"' OD V$ +% + V$>%>/37;&0 0D'0D&0D ,0D 5 0D !$ 0D 6; 0Dd Y'(F,0-2 +F &* +F%+F%+F)+F+ +F /4 +FZ V$O%O0(RZZ_$((.(.!(.(.%*(.V w/0111( $!& &( &( &(&( &(,1 &(R<*#($$ $-2$> V$>%>%)&++.+.!+.$+.16+.Z V$(%($ "(-))%)27)> V$(%(A)H$(05'"; / $ !67  DNP~~t~~ K$'(~~t~~ K$'(&+-/CN+!%"',2 ,2,2 ,2-2,2b$(%*'B'B 'B#'B05'BT => :? : Y'(, Y''('T V$>%>,#'"%****** **+0**\#("&*&* &*&*(-&*P Y' -( -& MM M M  M  M  M Mb$)%%!%.3%: V$>%>%*&&"&/4&: V$;%;"&#(#'#'#'!#'.3#'J V$%#"# "# "#"#)."#H V$ #% #"%)&+$+$+!$+$$+16$+L V$ %  !# *- *- *-*- *-). *-X V$ % (!%((("(-2(: V$3%3 $)%%!%.3%B V$,%,)+16 !>'!> )!>!&!>!/ !>H V$ 1% 1$ "(- !? !?(!?!?& !?38 !?H V$K%K 5 5 5  5   5  5  5 t !! ! !  !  !L EEE E  E  EF$(%*$-$- $-#$-05$-L V$  %  $!&%(%(%(%(,1%(N V$ % (%)$'#*#*!#*"#*-2#*J V$ % &&*', ,;,;,; ,;# ,; % ,; 27 ,;\ VD1 2 $",A$(&+!.!.!!.$!.16!.F VD12O0 Yt454 Yt4,B5,B^ VD1727|! ,, ,,,,,,  ,,  ,,  ,,` /^$ -~&~'78!93 939393  93  93 93x"r)