`iddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl Z ddl m Z ddl mZddlmZddlmZddl mZddlZdZd ZGd d eZdd Ziaejd ZdZdZdZdS)N) LinAlgError)_core)cuda)device)_kernels)_utilllceZdZdZd[dZdZdZdefdZde fdZ defdZ defd Z d defd Z defd Zd defd Zde fdZde fdZejddddZdd defdZdd defdZdd defdZde fdZddddefdZde fdZdd defdZdefdZdefd Zdefd!Zd de fd"Zdefd#Z d$Z!d%Z"ejd&d'd(d)Z#d*Z$defd+Z%d defd,Z&ejd-d.d/d0Z'ejd-d1d2d3Z(d4Z)d5Z*d6Z+ejd7d8d9d:Z,d\d;Z-defd<Z.defd=Z/defd>Z0defd?Z1defd@Z2d\dAZ3ejdBd'dCdDZ4defdEZ5ejdFd'dGdHZ6dd defdIZ7defdJZ8ejdKdLdMdNZ9defdOZ:defdPZ;de fdQZdUZ?dVZ@ejdddWdXZAdd defdYZBdde fdZZCdS)^ RandomStateaVPortable container of a pseudo-random number generator. An instance of this class holds the state of a random number generator. The state is available only on the device which has been current at the initialization of the instance. Functions of :mod:`cupy.random` use global instances of this class. Different instances are used for different devices. The global state for the current device can be obtained by the :func:`cupy.random.get_random_state` function. Args: seed (None or int): Seed of the random number generator. See the :meth:`~cupy.random.RandomState.seed` method for detail. method (int): Method of the random number generator. Following values are available:: cupy.cuda.curand.CURAND_RNG_PSEUDO_DEFAULT cupy.cuda.curand.CURAND_RNG_PSEUDO_XORWOW cupy.cuda.curand.CURAND_RNG_PSEUDO_MRG32K3A cupy.cuda.curand.CURAND_RNG_PSEUDO_MTGP32 cupy.cuda.curand.CURAND_RNG_PSEUDO_MT19937 cupy.cuda.curand.CURAND_RNG_PSEUDO_PHILOX4_32_10 Ncddlm}||j}|||_t j||j|j|_||_ | |dS)Nrcurand) cupy_backends.cuda.libsr CURAND_RNG_PSEUDO_DEFAULTcreateGenerator _generatorweakreffinalizedestroyGenerator _finalizermethodseed)selfrrr s j/home/jaya/work/projects/VOICE-AGENT/VIET/agent-env/lib/python3.11/site-packages/cupy/random/_generator.py__init__zRandomState.__init__8sp222222 >5F 0088!* &)4?<<  $c4|j|ztz|_dSN)_rk_seed _UINT64_MAX)rsizes r _update_seedzRandomState._update_seedCs-< rctj|}tj|}|dzdkr7t j||}||j|jj|j g|R|St j|dzf|}||j|jj|j g|R|d| |S)Nrdtype) rget_sizeinternalprodcupyemptyrdataptrr reshape)rfuncr r%args element_sizeouts r_generate_normalzRandomState._generate_normalFs ~d##~**400 ! q *T///C D#(, @4 @ @ @ @J*lQ.0>>>C D#(, @4 @ @ @ @} }%--d33 3rc&tj|tj|}}|tj||j}tj||}t j|||j|||j |S)zReturns an array of samples drawn from the beta distribution. .. seealso:: - :func:`cupy.random.beta` for full documentation - :meth:`numpy.random.RandomState.beta` Nshaper%) r*asarray broadcastr6r+r beta_kernelrr!r )rabr r%ys rbetazRandomState.betaYs~|A Q1 <>!Q''-D JT / / /Q4=!444 !&!!!rc&tj|tj|}}|tj||j}tj||}t j|||j|||j |S)zReturns an array of samples drawn from the binomial distribution. .. seealso:: - :func:`cupy.random.binomial` for full documentation - :meth:`numpy.random.RandomState.binomial` Nr5) r*r7r8r6r+rbinomial_kernelrr!r rnpr r%r<s rbinomialzRandomState.binomialhs~|A Q1 <>!Q''-D JT / / / At}a888 !&!!!rctj|}||j}tj||}t j||j|||j|S)zReturns an array of samples drawn from the chi-square distribution. .. seealso:: - :func:`cupy.random.chisquare` for full documentation - :meth:`numpy.random.RandomState.chisquare` Nr5) r*r7r6r+rchisquare_kernelrr!r rdfr r%r<s r chisquarezRandomState.chisquarewse\"   <8D JT / / /!"dmQ777 !&!!!rcztj|}||j}n7t|ttjfr |f|jz}n ||jz }tj||}tj||j ||| ddz}| |j |S)zReturns an array of samples drawn from the dirichlet distribution. .. seealso:: - :func:`cupy.random.dirichlet` for full documentation - :meth:`numpy.random.RandomState.dirichlet` Nr5T)axiskeepdims) r*r7r6 isinstanceintintegerr+rstandard_gamma_kernelrsumr!r )ralphar r%r<s r dirichletzRandomState.dirichlets U## <;DD sDL1 2 2 7U[(DD EK D JT / / /&udmQ??? QUUTU * ** !&!!!r?ctj||}|dkrtd||j}|||}||z}|S)a.Returns an array of samples drawn from a exponential distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.exponential` for full documentation - :meth:`numpy.random.RandomState.exponential` r scale < 0)r*r7any ValueErrorr6standard_exponentialrscaler r%xs r exponentialzRandomState.exponentialsh UE** AI??   *[)) ) <;D  % %dE 2 2 U rc&tj|tj|}}|tj||j}tj||}t j|||j|||j |S)zReturns an array of samples drawn from the f distribution. .. seealso:: - :func:`cupy.random.f` for full documentation - :meth:`numpy.random.RandomState.f` Nr5) r*r7r8r6r+rf_kernelrr!r )rdfnumdfdenr r%r<s rfz RandomState.fs|E**DL,?,?u <>%//5D JT / / /% q999 !&!!!rc.tj|tj|}}|tj||j}tj||}t j||j|||z}||j |S)zReturns an array of samples drawn from a gamma distribution. .. seealso:: - :func:`cupy.random.gamma` for full documentation - :meth:`numpy.random.RandomState.gamma` Nr5) r*r7r8r6r+rrPrr!r )rr6r[r r%r<s rgammazRandomState.gammas|E**DL,?,?u <>%//5D JT / / /&udmQ??? U  !&!!!rctj|}||j}tj||}t j||j|||j|S)zReturns an array of samples drawn from the geometric distribution. .. seealso:: - :func:`cupy.random.geometric` for full documentation - :meth:`numpy.random.RandomState.geometric` Nr5) r*r7r6r+rgeometric_kernelrr!r rrBr r%r<s r geometriczRandomState.geometricsc LOO <7D JT / / /!!T]A666 !&!!!rcRtj|tj|tj|}}}|tj|||j}tj||}t j||||j|||j |S)zReturns an array of samples drawn from the hypergeometric distribution. .. seealso:: - :func:`cupy.random.hypergeometric` for full documentation - :meth:`numpy.random.RandomState.hypergeometric` Nr5) r*r7r8r6r+rhypergeometric_kernelrr!r )rngoodnbadnsampler r%r<s rhypergeometriczRandomState.hypergeometrics L  d!3!3T\'5J5Jt <>%w77=D JT / / /&udGT]ANNN !&!!!rzT x, T loc, T scalezT yz>y = loc + scale * ((x <= 0.5) ? log(x + x): -log(x + x - 1.0))cupy_laplace_kernelctj||}tj||}|tj||j}|||}t |||||S)zReturns an array of samples drawn from the laplace distribution. .. seealso:: - :func:`cupy.random.laplace` for full documentation - :meth:`numpy.random.RandomState.laplace` )r*r7r8r6_random_sample_rawr _laplace_kernelrlocr[r r%r\s rlaplacezRandomState.laplacessl3&& UE** <>#u--3D  # #D% 0 0##AsE1555rctj|tj|}}|tj||j}tj||}t j|j|||j d|z |z }tj ||tj |||tj ||||S)zReturns an array of samples drawn from the logistic distribution. .. seealso:: - :func:`cupy.random.logistic` for full documentation - :meth:`numpy.random.RandomState.logistic` Nr5rTr2) r*r7r8r6r+ropen_uniform_kernelrr!r logmultiplyaddrts rlogisticzRandomState.logistics\#&& U(;(;U <>#u--3D JT / / /$T]A666 !&!!! 1WM  aA&&&& CQrc0ddlm}td||fDr0|||||}t j|||S|d}t |}|jdkr|j}n|j }| |||||S)zReturns an array of samples drawn from a log normal distribution. .. seealso:: - :func:`cupy.random.lognormal` for full documentation - :meth:`numpy.random.RandomState.lognormal` rr c3JK|]}t|tjVdSr)rMr*ndarray).0args r z(RandomState.lognormal..s.FFz#t|,,FFFFFFrrxNrb) rr rWnormalr*exp_check_and_get_dtypechargenerateLogNormalgenerateLogNormalDoubler3)rmeansigmar r%r r\r/s r lognormalzRandomState.lognormals 322222 FFu FFF F F  D%u55A HQA    H <D$U++ :  +DD1D$$T4eDDDrcrtj|}tj|dkrtdtj|dkrtd||j}tj||}t j||j|| |j |S)a*Returns an array of samples drawn from a log series distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.logseries` for full documentation - :meth:`numpy.random.RandomState.logseries` rzp <= 0.0r&zp >= 1.0Nr5) r*r7rWrXr6r+rlogseries_kernelrr!r rgs r logserieszRandomState.logseries*s LOO 8AF   )Z(( ( 8AF   )Z(( ( <7D JT / / /!!T]A666 !&!!!rignoreg:0yE>choleskyc \ tjdtj||}tj||}|g}n't |t tjfr|g}n|}t|jdkrtdt|jdks|jd|jdkrtd|jd|jdkrtd t|dd} | |jd|d vrtd |d kr|d kr|dkrtd|d krtj d5 tj|} na#t $rStj d 5|dkr|dkrsvdeighrz1method must be one of {'eigh', 'svd', 'cholesky'}rwarnraisez3check_valid must equal 'warn', 'raise', or 'ignore')linalgrrr)rtolatolz?covariance is not positive-semidefinite, output may be invalid.z=covariance is not positive-semidefinite, output *is* invalid.z_Matrix is not positive definite; if matrix is positive-semidefinite, set'check_valid' to 'warn'rJ)r experimentalr*r7rMrNrOlenr6rXlistappendcupyxerrstaterrrrrWrallclosedotTsqrtabswarningsrRuntimeWarningstandard_normalr.tuple)rrcovr check_validtolrr%r6 final_shapedecompsupsdvhr\s rmultivariate_normalzRandomState.multivariate_normalBs{ HIII|D...l3e,,, <EE sDL1 2 2 FEEE tz??a  9:: :  NNa  SYq\SYq\%A%ACDD D :a=CIaL ( (ABB B58nn 4:a=))) 4 4 4CEE E ( " "f$$)?)? IKKK & w/// ? ??![11#66FF"???x888??!Z//%//)-)9)9#)>)>A*.(1t8*<*<&<%-1[__S-A-A Ar&*mDHRTAXr4J4J47c'M'M'M%&48A;;)?)?%?F#&J ( /9:H!J!J!J %M+56DFFF&*[%9%9#%>%>F'???????????????? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?4{333 A A A++!%!5!5c!:!:6))!%!1!1#!6!6A!"TYtx{{%;%;!;5%)[__S%9%9 Ar!"TYtx{{%;%;!;"AAA%'@AAAA A A A A A A A A A A A A A A A  ', ! . ..5gb$*Q-.H.H HVQS ! ! C T  $$s L F,*L, L  D$K<0 L <L L L L L L  LL L;P1=C PP1P""P11P58P5ctj|}tj|}tj|dkrtdtj|dkrtdtj|dkrtd||d|z |z |}|||S)aBReturns an array of samples drawn from the negative binomial distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.negative_binomial` for full documentation - :meth:`numpy.random.RandomState.negative_binomial` rzn <= 0zp < 0r&zp > 1r$)r*r7rWrXrdpoissonr@s rnegative_binomialzRandomState.negative_binomials LOO LOO 8AF   'X&& & 8AE?? &W%% % 8AE?? &W%% % JJq1Q3'4 ( (||AU|+++rc(ddlm}t|}|tj||j}|jdkr|j}n|j}t|tj rH| |||dd}tj |||tj |||ndt|tj r1| |||d|}tj |||n| |||||}|S)zReturns an array of normally distributed samples. .. seealso:: - :func:`cupy.random.normal` for full documentation - :meth:`numpy.random.RandomState.normal` rr NrbrprTrx)rr rr*r8r6rgenerateNormalgenerateNormalDoublerMrr3r{r|)rrur[r r%r r/r\s rrzRandomState.normals& 322222$U++ <>#u--3D :  (DD.D eT\ * * E%%dD%cBBA M!U * * * * HQ # # # # # T\ * * E%%dD%eDDA HQ # # # # #%%dD%eDDArctj|}||j}|||}tj||tj| |z ||dz S)zReturns an array of samples drawn from the pareto II distribution. .. seealso:: - :func:`cupy.random.pareto` for full documentation - :meth:`numpy.random.RandomState.pareto` Nrxr&)r*r7r6rrrzrrr:r r%r\s rparetozRandomState.paretosk LOO <7D  # #D% 0 0  !A11u rctj|tj|}}tj|dkrtdtj|dkrtd|tj||j}tj||}tj|||j || |j |S)aTReturns an array of samples drawn from the noncentral chi-square distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.noncentral_chisquare` for full documentation - :meth:`numpy.random.RandomState.noncentral_chisquare` rzdf <= 0nonc < 0Nr5) r*r7rWrXr8r6r+rnoncentral_chisquare_kernelrr!r )rrGnoncr r%r<s rnoncentral_chisquarez RandomState.noncentral_chisquares<##T\$%7%7D 8B!G   (Y'' ' 8D1H   )Z(( ( <>"d++1D JT / / /,Rt}aHHH !&!!!rc<tj|tj|tj|}}}tj|dkrtdtj|dkrtdtj|dkrtd|tj|||j}tj||}tj||||j || |j |S)a3Returns an array of samples drawn from the noncentral F distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.noncentral_f` for full documentation - :meth:`numpy.random.RandomState.noncentral_f` rz dfnum <= 0z dfden <= 0rNr5) r*r7rWrXr8r6r+rnoncentral_f_kernelrr!r )rr`rarr r%r<s r noncentral_fzRandomState.noncentral_fs L  e!4!4dl46H6Hu 8EQJ   +\** * 8EQJ   +\** * 8D1H   )Z(( ( <>%55;D JT / / /$UE4JJJ !&!!!rctj|}||j}tj||}t j||j|||j|S)zReturns an array of samples drawn from the poisson distribution. .. seealso:: - :func:`cupy.random.poisson` for full documentation - :meth:`numpy.random.RandomState.poisson` Nr5) r*r7r6r+rpoisson_kernelrr!r )rlamr r%r<s rrzRandomState.poissonsel3 <9D JT / / /T]A666 !&!!!rcNtj|}tj|dkrtd||j}|||}tj| |tjd| |tj|d|z ||S)aReturns an array of samples drawn from the power distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.power` for full documentation - :meth:`numpy.random.RandomState.power` ra < 0Nr r%rxr&rT) r*r7rWrXr6rYrr|powerrs rrzRandomState.power$s LOO 8AE?? &W%% % <7D  % %4u % = = ! QBA 1bd""""rc|dt}|r7tdd|z|||S)zReturns uniform random values over the interval ``[0, 1)``. .. seealso:: - :func:`cupy.random.rand` for full documentation - :meth:`numpy.random.RandomState.rand` r%z*rand() got unexpected keyword arguments %s, r)popfloat TypeErrorjoinkeys random_samplerr kwargr%s rrandzRandomState.rand:si '5))  7H"ii 55677 7!!t5!999rc|dt}|r7tdd|z|||S)zReturns an array of standard normal random values. .. seealso:: - :func:`cupy.random.randn` for full documentation - :meth:`numpy.random.RandomState.randn` r%z+randn() got unexpected keyword arguments %srr)rrrrrrrs rrandnzRandomState.randnHsf '5))  7I"ii 55677 7{{E{222rzT xzx = (x == (T)1) ? 0 : xcupy_random_x_mod_1cddlm}t|}tj||}|jdkr|j}n|j}||j|j j |j |S)Nrr r$rb) rr rr*r+rgenerateUniformgenerateUniformDoublerr,r-r )rr r%r r2r/s rrrzRandomState._random_sample_rawYsu222222$U++jU+++ :  )DD/D T_chlCH555 rcn|d}|||}t||S)zReturns an array of random values over the interval ``[0, 1)``. .. seealso:: - :func:`cupy.random.random_sample` for full documentation - :meth:`numpy.random.RandomState.random_sample` Nr)rrr _mod1_kernel)rr r%r2s rrzRandomState.random_samplees< <D%%dE22  %%% rcntj|}||j}tj|dkrt d|||}tj||}tj|d|}tj||}tj|||}|S)a%Returns an array of samples drawn from a rayleigh distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.rayleigh` for full documentation - :meth:`numpy.random.RandomState.rayleigh` NrrVrxg) r*r7r6rWrXrrrzr{rrZs rrayleighzRandomState.rayleighss U## <;D 8EAI   *[)) )  # #D% 0 0 HQA    M!Sa ( ( ( IaQ    M!U * * *rz T max, T mxzT outz3out = max - (mx != max ? (max - mx) % (mx + 1) : 0) cupy_random_interval_upper_limitzT samplez$if (mx != max) { sample %= mx + 1; }"cupy_random_interval_sample_moduloc|d}nt|tr|f}tj|}|r|dkr t j|tjS|dkr"td||tkr'tj}|td|dzzz }n;|tkr'tj }|td|dzzz }n td ||j }|tj ks|tjkr?tj}||d }|t|}n|tjks|tj kr?tj }||d }|t|}n"td |t#jt&j|d}|dkrt j||S|||}|rW|dz}|d|dz zkr4d|zdz } || z}||S|||d } | j} | dkrtj|s|| }| dkr|rt7| d zdn|j} || |} || |d}|j}|| kr| |d| || <d} n.| ||| d|<| |d} |s ||d}| |z} | dk|r||z}nI|tjkr|t||}n|t||}||S)a`Generate multiple integers independently sampled uniformly from ``[0, mx]``. Args: mx (int): Upper bound of the interval size (None or int or tuple): Shape of the array or the scalar returned. Returns: int or cupy.ndarray: If ``None``, an :class:`cupy.ndarray` with shape ``()`` is returned. If ``int``, 1-D array of length size is returned. If ``tuple``, multi-dimensional array with shape ``size`` is returned. Currently, only 32 bit or 64 bit integers can be sampled. Nrrr$z$mx must be non-negative (actual: {})r&z+mx must be within uint64 range (actual: {})Fcopyzdtype must be integer, got: {}r#iT)rMrNnumpyisscalarr*zerosuint32rXformat _UINT32_MAXruint64r%int32astype_interval_upper_limitint64 functoolsreduceoperatormulr+_curand_generate bit_lengthr. _get_indicesr max_interval_sample_modulo)rmxr is_mx_scalarr% upper_limitn_samplesamplemx1mask ng_indicesn_ng n_supplement supplement ok_indicesn_oks r _intervalzRandomState._intervals <DD c " " 5D~b))  DQwwz$el;;;;Avv :AA"EEGGG{"" #eK7rAv2F$FGG {"" #eK7rAv2F$FGG  AHHLLNNNHE ""et{&:&: YYu5Y11"88bII $*$$(<(< YYu5Y11"88bII  4;;EBBDDD#HL$:: q==:d%000 0&&x77  ,q&CaCNN,,q0111R]]__,1$~~d+++&&v{EBB  !88EN2..8%j1KQhh+BCq$///1<1A ..|UCCJ**:{DIIJ?Dt||%/ 5D50A%Bz",6z,Bz%4%()'. #5"-dee"4K %Qhh(  K cMFF dk ! !11+r6JJFF11+r6JJF~~d###rcddlm}tj|f|}|t jj}||j |j j ||S)Nrr r$) rr r*r+viewrrr generaterr,r-)rnumr%r rsize32s rrzRandomState._curand_generatesc222222SF%0005<005&AAA rc$|jdkr tjn tj}|r||kn||k}t j||}~t jt|df|}||||j|S)Nrr$rJr ) r rrrr*cumsumr+rN_kernel_get_indices)rrrcondr%flagscsumindicess rrzRandomState._get_indicess & e 3 3 +/K;&&f{6J{5... *c$r(mm-U;;;   wTY ???rz raw U csumz raw U indiceszo int j = 0; if (i > 0) { j = csum[i-1]; } if (csum[i] > j) { indices[j] = i; } cupy_get_indicescddlm}|f tjt jd}t |d}n#t$r!tjdztz}YnwxYwt|tj r?t tj|dddd}n[tj|}|jjd vrt'd t |}|dks|d krt)d ||j||j|j|jfvr||jd||_dS) zResets the state of the random number generator with a seed. .. seealso:: - :func:`cupy.random.seed` for full documentation - :meth:`numpy.random.RandomState.seed` rr Ni@BF)usedforsecuritybiuzSeed must be an integer.rz/Seed must be an integer between 0 and 2**64 - 1)rr binasciihexlifyosurandomrNNotImplementedErrortimerrMrrhashlibmd5 hexdigestr7r%kindrrXsetPseudoRandomGeneratorSeedrrCURAND_RNG_PSEUDO_MT19937CURAND_RNG_PSEUDO_MTGP32setGeneratorOffsetr)rrr seed_strseed_arrs rrzRandomState.seeds 322222 < =#+BJqMM::8R((& = = = g-< =$ .. K7;%1111:SbSBCEGG!=..>&e33#$>???8}}!88tu}}$IKKK ++DOTBBB K @ & ? A A A  % %doq 9 9 9 s6A(A,+A,cx|||}tjtj|dz zS)zReturns an array of samples drawn from the standard cauchy distribution. .. seealso:: - :func:`cupy.random.standard_cauchy` for full documentation - :meth:`numpy.random.RandomState.standard_cauchy` rg?)uniformr*tanpirr r%r\s rstandard_cauchyzRandomState.standard_cauchy7s4 LLd%L 0 0x1s7+,,,rcd|d}|||}tj|| S)zReturns an array of samples drawn from the standard exp distribution. .. seealso:: - :func:`cupy.random.standard_exponential` for full documentation - :meth:`numpy.random.RandomState.standard_exponential` Nrrx)rrr*rzr2s rrYz RandomState.standard_exponentialAs; <D  # #D% 0 0"""""rctj|}||j}tj||}t j||j|||j|S)zReturns an array of samples drawn from a standard gamma distribution. .. seealso:: - :func:`cupy.random.standard_gamma` for full documentation - :meth:`numpy.random.RandomState.standard_gamma` Nr5) r*r7r6r+rrPrr!r )rr6r r%r<s rstandard_gammazRandomState.standard_gammaMse U## <;D JT / / /&udmQ??? !&!!!rc0|||S)zReturns samples drawn from the standard normal distribution. .. seealso:: - :func:`cupy.random.standard_normal` for full documentation - :meth:`numpy.random.RandomState.standard_normal` r)r)rr r%s rrzRandomState.standard_normal\s{{E{222rctj|}||j}tj||}t j||j|||j|S)zReturns an array of samples drawn from the standard t distribution. .. seealso:: - :func:`cupy.random.standard_t` for full documentation - :meth:`numpy.random.RandomState.standard_t` Nr5) r*r7r6r+rstandard_t_kernelrr!r rFs r standard_tzRandomState.standard_tfse\"   <8D JT / / /"2t}a888 !&!!!rc ddlm}|d}tj|tj}|jjdz}||j|j j |j |z|tj tjj z}|S)aDraws integers between 0 and max integer inclusive. Return a sample of uniformly distributed random integers in the interval [0, ``np.iinfo(np.int_).max``]. The `np.int_` type translates to the C long integer type and its precision is platform dependent. Args: size (int or tuple of ints): Output shape. Returns: cupy.ndarray: Drawn samples. .. seealso:: :meth:`numpy.random.RandomState.tomaxint` rr Nrr$)rr r*r+int_r%itemsizer rr,r-r iinfor)rr r r size_in_ints rtomaxintzRandomState.tomaxintus" 322222 <DD 222l+q0  OV[_fkK.G I I I $*TY''++ rzL left, M mode, R righta T base, leftbase, ratio, leftprod, rightprod; base = right - left; leftbase = mode - left; ratio = leftbase / base; leftprod = leftbase*base; rightprod = (right - mode)*base; if (x <= ratio) { x = left + sqrt(x*leftprod); } else { x = right - sqrt((1.0 - x) * rightprod); } cupy_triangular_kernelctj|tj|tj|}}}tj||krtdtj||krtdtj||krtd|tj|||j}|||}t||||S)a-Returns an array of samples drawn from the triangular distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.triangular` for full documentation - :meth:`numpy.random.RandomState.triangular` z left > modez mode > rightz left == rightNr) r*r7rWrXr8r6rr _triangular_kernel)rleftmoderightr r%r\s r triangularzRandomState.triangulars L   T 2 2DL4G4Gd 8D4K  ,]++ + 8D5L ! ! -^,, , 8DEM " " ._-- - <>$e44:D   D  6 6--dD%CCCrz T low, T highzx = T(low) + x * T(high - low) cupy_scalecltj|stj||}tj|stj||}|tj||j}tj|}|||}t |||S)zReturns an array of uniformly-distributed samples over an interval. .. seealso:: - :func:`cupy.random.uniform` for full documentation - :meth:`numpy.random.RandomState.uniform` Nr) rrr*r7r8r6r%rr _scale_kernel)rlowhighr r%rs rr/zRandomState.uniforms~c"" +,sE**C~d## -<e,,D <>#t,,2D E""!!t5!99((dD999rc&tj|tj|}}|tj||j}tj||}t j|||j|||j |S)zReturns an array of samples drawn from the von Mises distribution. .. seealso:: - :func:`cupy.random.vonmises` for full documentation - :meth:`numpy.random.RandomState.vonmises` Nr5) r*r7r8r6r+rvonmises_kernelrr!r )rmukappar r%r<s rvonmiseszRandomState.vonmisessL$$dl5&9&9E <>"e,,2D JT / / / UDM1=== !&!!!rzT mean, T scale, T UzT Xa  T mu_2l; T Y; mu_2l = mean / (2*scale); Y = mean*X*X; X = mean + mu_2l*(Y - sqrt(4*scale*Y + Y*Y)); if (U > mean/(mean+X)) { X = mean*mean/X; } cupy_wald_scalec(tj||tj||}}|tj||j}|||}|||}t ||||S)zReturns an array of samples drawn from the Wald distribution. .. seealso:: - :func:`cupy.random.wald` for full documentation - :meth:`numpy.random.RandomState.wald` r$Nr)r*r7r8r6rrr _wald_kernel)rrr[r r%r\rs rwaldzRandomState.walds LU + + +T\%u-M-M-M <>$..4D KKTK / /   D  6 6''eQ:::rctj|}tj|dkrtd||j}|||}tj|d|z ||S)a$Returns an array of samples drawn from the weibull distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.weibull` for full documentation - :meth:`numpy.random.RandomState.weibull` rrNrTrx)r*r7rWrXr6rYrrs rweibullzRandomState.weibullst LOO 8AE?? &W%% % <7D  % %dE 2 2 1bd""""rc$tj|}tj|dkrtd||j}tj||}t j||j|| |j |S)aReturns an array of samples drawn from the Zipf distribution. .. warning:: This function may synchronize the device. .. seealso:: - :func:`cupy.random.zipf` for full documentation - :meth:`numpy.random.RandomState.zipf` rTz'a' must be a valid float > 1.0Nr5) r*r7rWrXr6r+r zipf_kernelrr!r )rr:r r%r<s rzipfzRandomState.zipfs LOO 8AH   B@AA A <7D JT / / /Q q111 !&!!!rTc|tdt|tjr|jdkrt t|t r|}|dkrtdn?tj|d}|jdkrtdt|}|tj|}|jdkrtdt||krtd |dk std tj | }tj |dstd |t d |}tj|}|dkr|dkrtd |s|||krtdt|t rtj|d}n|}|||d||S|st |tj|||f}tjtj||||fzd} t|t stj| |} nA|dkrd}|d||} | tjd} t|t r| S| jdkr!tj|| |jS|| S)zReturns an array of random values from a given 1-D array. .. seealso:: - :func:`cupy.random.choice` for full documentation - :meth:`numpy.random.choice` Nz%a must be 1-dimensional or an integerrz$a must be greater than or equal to 0Frr&zp must be 1-dimensionalza and p must have same sizez"probabilities are not non-negativezprobabilities do not sum to 1z5choice() without specifying size is not supported yetz-a cannot be empty unless no samples are takenz@Cannot take a larger sample than population when 'replace=False'lr$r)rK)rXrMr*rndimr"rNarrayrallrQgetrrr)arangershuffler. broadcast_toargmaxrzgumbelrandintrrr%) rr:r replacerBa_sizep_sumr6rindexs rchoicezRandomState.choice3sG 9DEE E a & & &16Q;;% % a   Fzz !GHHH 15)))Av{{ !HIIIVVF = 1 Av{{ !:;;;1vv !>???F<<>> G !EFFFHQKKOO%%E>%++ B !@AAA <%GII Iz%   Q;;4!88LMM M 119}} ()))!S!! #+as333&&(( LL ! ! !5D5>))%00 0 &% % =!!dF^44AK $ $ @ @!A%&(((EeS)) 3 UE22{{LLFL77ELL%L88E a   L :??:ahag666 6xrct|tjstd|jdkrtd||t ||dd<dS)zReturns a shuffled array. .. seealso:: - :func:`cupy.random.shuffle` for full documentation - :meth:`numpy.random.shuffle` zThe array must be cupy.ndarrayrz)An array whose ndim is 0 is not supportedN)rMr*rrr^ _permutationrrr:s rrczRandomState.shufflesk!T\** ><== = 6Q;;GHH H""3q66**+!!!rct|tr||S||t|S)z6Returns a permuted range or a permutation of an array.)rMrNrnrros r permutationzRandomState.permutationsG a   0$$Q'' 'T&&s1vv../ /rcddlm}tj|ftj}||j|jj |tj |}|S)zReturns a permuted range.rr r$) rr r*r+rrr rr,r-argsort)rrr rr_s rrnzRandomState._permutations\222222SF%+666#>>> V$$ rz$y = T(loc) - log(-log(x)) * T(scale)cupy_gumbel_kernelcJtj|stj||}tj|stj||}|tj||j}|||}t|||||S)zReturns an array of samples drawn from a Gumbel distribution. .. seealso:: - :func:`cupy.random.gumbel` for full documentation - :meth:`numpy.random.RandomState.gumbel` Nr) rrr*r7r8r6rrr _gumbel_kernelrts rrfzRandomState.gumbels~c"" +,sE**C~e$$ /L..E <>#u--3D  # #U # ; ;""1c5!444rctj|s tj|}|tj|}|dz }n|}tj|dz }|tj||j}||z }tjtj |d}| | |} | |} tj| |} | |d}tj| || | S|d}t!|dz } n!t!|}t!|dz } || krt#d|tj|jkr9t#dtj|j| tj|jkr9t#d tj|j| |z }| || |d} tj| || | S) zReturns a scalar or an array of integer values over ``[low, high)``. .. seealso:: - :func:`cupy.random.randint` for full documentation - :meth:`numpy.random.RandomState.randint` Nr&Frrxrz low >= highzlow is out of bounds for {}zhigh is out of bounds for {})rrr*r7 zeros_liker8r6rrrrr flattenrr.r|rNrXr?minrr%namer) rrLrMr r%lohidiff total_elemsr2hi1r\s rrgzRandomState.randints8~c""* ,s##C|_S))1W\$''!+|~b"--37D#*8<qAAK..==C**U##C,sD))C5u--B HS"# & & & &J|#hhlXX$ii!mCxx ///DJu%%))) 188 5)).00111TZ&&*** 299 5)).001118DtT**11%e1DDA HQ " " " "Hr)NNr)NTN)D__name__ __module__ __qualname____doc__rr!r3rr=rNrCrHrSr]rbrdrhrnrElementwiseKernelrsrvr}rrrrrrrrrrrrrrrrrrrr rrrrr3rYr6rr:rArDrHrKr/rRrUrVrXr[rlrcrqrnrvrfrgrrrr r sZ4    ===444&#%    #'c    "&U    %)(!$$e($(u    "%4u !%C    9=C .e-uHO St5    cE&!$eEEEE.!%C037H %j^^^^@,0s,,,,,Cd%8"    37e0594D    !, : : : 3 3 3+5* E,.CEEL   "&U    !t5.4E3w=*,, 6e5z.,.. a$a$a$F2%1o ####J$(u----)-E # # # #*.U    $(u3333#'e    >10!5 " !',26UDDDD0,E+(M Cd%::::((,5    +5*    L&* ; ; ; ;#%, s*NNNN`,,, 000-U,u.N Cd%"!%4s111111rr cHt|dS)aResets the state of the random number generator with a seed. This function resets the state of the global random number generator for the current device. Be careful that generators for other devices are not affected. Args: seed (None or int): Seed for the random number generator. If ``None``, it uses :func:`os.urandom` if available or :func:`time.time` otherwise. Note that this function does not support seeding by an integer array. N)get_random_stater)rs rrrs$D!!!!!rc iadSr)_random_statesrrr reset_statesrs NNNrc<tj}t|jd}|ft jd}|!tjt|}t|}t |j|}|S)aXGets the state of the random number generator for the current device. If the state for the current device is not created yet, this function creates a new one, initializes it, and stores it as the state for the current device. Returns: RandomState: The state of the random number generator for the device. N CUPY_SEED) rDevicerraidr getenvrrrNr setdefault)devrsrs rrr s~ +--C   CFD ) )B zy%%  <D **D     & &svr 2 2 Irct|ts/tdt ||t t j<dS)zSets the state of the random number generator for the current device. Args: state(RandomState): Random state to set for the current device. z;Random state must be an instance of RandomState. Actual: {}N)rMr rrtyperr get_device_id)rs rset_random_stater s[ b+ & &+ R))++ +.0N6'))***rc^tj|}|jdvrtd|S)N)rbdz-cupy.random only supports float32 and float64)rr%rrr$s rrr-s2 K  E z##GHHH Lrr) atexitrrr$rr r#rrr numpy.linalgrr*rr cupy.cudar cupy.randomrrrrrobjectr rrregisterrrrrrrrrs   $$$$$$     NNNNN&NNNb&""""& . 0 0 0r