9j JSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK Jr SSKrSSKJr SSKJr SSKJr SSKJr SSKJr SS KJr SSKrSSKrS r\"S 5rS rS r"SS5rSSjr 0q!\RDS5r#Sr$Sr%Sr&g)) annotationsN) LinAlgError)_core)cuda)device)_kernels)FeistelBijection)_utilc([RRU5n[RRUR5nX!l[RR U5nU[ RU'URU5 U$N) importlibutil find_spec LazyLoaderloadermodule_from_specsysmodules exec_module)namespecrmodules P/home/wildlama/miniconda3/lib/python3.13/site-packages/cupy/random/_generator.py lazy_importrsh >> # #D )D ^^ & &t{{ 3FK ^^ , ,T 2FCKK v Mcupyxllc \rSrSrSrS\SjrSrSrS\4Sjr S\ 4Sjr S\4S jr S\4S jr S S\4S jrS\4S jrS S\4SjrS]SjrS]Sjr\R("SSSS5rSS S\4SjrSS S\4SjrSS S\4SjrS]SjrSSSS\4SjrS\ 4SjrSS S\4SjrS\4S jrS\4S!jrS\4S"jrS^S#jr S\4S$jr!S%r"S&r#\R("S'S(S)S*5r$S+r%S\4S,jr&S S\4S-jr'\R("S.S/S0S15r(\R("S.S2S3S45r)S5r*S6r+S7r,\R("S8S9S:S;5r-S_S<jr.S\4S=jr/S\4S>jr0S\4S?jr1S\4S@jr2S\4SAjr3S_SBjr4\R("SCS(SDSE5r5S\4SFjr6\R("SGS(SHSI5r7SS S\4SJjr8S\4SKjr9\R("SLSMSNSO5r:S\4SPjr;S\4SQjrSTr?SUr@SVrA\R("SSSWSX5rBSS S\4SYjrCSS\ 4SZjrDS[rEg)a RandomState.a Portable 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 NcSSKJn Uc URn[R"5UlUR U5Ul[R"XRUR5Ul X l URU5 g)Nrcurand)cupy_backends.cuda.libsr"CURAND_RNG_PSEUDO_DEFAULT threadingLock_lockcreateGenerator _generatorweakreffinalizedestroyGenerator _finalizermethodseed)selfr/r.r"s r__init__RandomState.__init__Jsh2 >55F^^%  008!** ))4??<  $rcUR URnX!-[-UlSSS5 U$!,(df  W$=fr )r'_rk_seed _UINT64_MAX)r0sizerk_seeds r _get_seedRandomState._get_seedZs; ZZmmG$^{:DMZs 4 Acj[R"U5n[RRU5nUS-S:Xa^[R "X#S9nUR  U"URURRUR/UQ76 SSS5 U$[R "US-4US9nUR  U"URURRUR/UQ76 SSS5 USURU5$!,(df  U$=f!,(df  N4=f)Nrdtype) rget_sizeinternalprodcupyemptyr'r)dataptrr6reshape)r0funcr6r=args element_sizeouts r_generate_normalRandomState._generate_normal`s ~~d#~~**40 ! q **T/CT__chhllCHHDtDJ**lQ.0>CT__chhllCHHDtD} %--d3 3Js4D4D$ D!$ D2c.[R"U5[R"U5p!Uc [R"X5Rn[R"X4S9nUR UR 5n[R"XXe5 U$)zReturns an array of samples drawn from the beta distribution. .. seealso:: - :func:`cupy.random.beta` for full documentation - :meth:`numpy.random.RandomState.beta` shaper=) rBasarray broadcastrOrCr8r6r beta_kernel)r0abr6r=yr7s rbetaRandomState.betausi||A Q1 <>>!'--D JJT /..(Q7.rc.[R"U5[R"U5p!Uc [R"X5Rn[R"X4S9nUR UR 5n[R"XXe5 U$)zReturns an array of samples drawn from the binomial distribution. .. seealso:: - :func:`cupy.random.binomial` for full documentation - :meth:`numpy.random.RandomState.binomial` rN) rBrPrQrOrCr8r6rbinomial_kernel)r0npr6r=rUr7s rbinomialRandomState.binomialsi||A Q1 <>>!'--D JJT /..(  w2rc[R"U5nUc URn[R"X#S9nUR UR 5n[ R"XU5 U$)zReturns an array of samples drawn from the chi-square distribution. .. seealso:: - :func:`cupy.random.chisquare` for full documentation - :meth:`numpy.random.RandomState.chisquare` rN)rBrPrOrCr8r6rchisquare_kernelr0dfr6r=rUr7s r chisquareRandomState.chisquaresU\\"  <88D JJT /..(!!"q1rc[R"U5nUc URnOD[U[[R 45(aU4UR-nOX!R- n[R "X#S9nURUR5n[R"XU5 XDRSSS9-nU$)zReturns an array of samples drawn from the dirichlet distribution. .. seealso:: - :func:`cupy.random.dirichlet` for full documentation - :meth:`numpy.random.RandomState.dirichlet` rNT)axiskeepdims) rBrPrO isinstanceintintegerrCr8r6rstandard_gamma_kernelsum)r0alphar6r=rUr7s r dirichletRandomState.dirichlets U# <;;D sDLL1 2 27U[[(D KK D JJT /..(&&uq9 UUTU **r?c[R"X5nUS:R5(a [S5eUc URnUR X#5nXA-nU$)zReturns 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)rBrPany ValueErrorrOstandard_exponentialr0scaler6r=xs r exponentialRandomState.exponentialsX U* AI??  [) ) <;;D  % %d 2 rc.[R"U5[R"U5p!Uc [R"X5Rn[R"X4S9nUR UR 5n[R"XXe5 U$)zReturns an array of samples drawn from the f distribution. .. seealso:: - :func:`cupy.random.f` for full documentation - :meth:`numpy.random.RandomState.f` rN) rBrPrQrOrCr8r6rf_kernel)r0dfnumdfdenr6r=rUr7s rf RandomState.fsk||E*DLL,?u <>>%/55D JJT /..(%3rc6[R"U5[R"U5p!Uc [R"X5Rn[R"X4S9nUR UR 5n[R"XU5 XR-nU$)zReturns an array of samples drawn from a gamma distribution. .. seealso:: - :func:`cupy.random.gamma` for full documentation - :meth:`numpy.random.RandomState.gamma` rN) rBrPrQrOrCr8r6rrk)r0rOrwr6r=rUr7s rgammaRandomState.gammasr||E*DLL,?u <>>%/55D JJT /..(&&uq9 rc[R"U5nUc URn[R"X#S9nUR UR 5n[ R"XU5 U$)zReturns an array of samples drawn from the geometric distribution. .. seealso:: - :func:`cupy.random.geometric` for full documentation - :meth:`numpy.random.RandomState.geometric` rN)rBrPrOrCr8r6rgeometric_kernelr0r[r6r=rUr7s r geometricRandomState.geometricsT LLO <77D JJT /..(!!!a0rcf[U[[45(aUS:a [S5e[U[[45(aUS:a [S5e[U[[45(aUS:a [S5e[R "U5[R "U5[R "U5p2nUc![R "XU5Rn[R"XES9nURUR5n[R"XX7U5 U$)zReturns an array of samples drawn from the hypergeometric distribution. .. seealso:: - :func:`cupy.random.hypergeometric` for full documentation - :meth:`numpy.random.RandomState.hypergeometric` rz ngood < 0znbad < 0r>z nsample < 1rN) rhrifloatrtrBrPrQrOrCr8r6rhypergeometric_kernel)r0ngoodnbadnsampler6r=rUr7s rhypergeometricRandomState.hypergeometrics ec5\ * *uqy[) ) dS%L ) )dQhZ( ( gU| , ,1]+ + LL d!3T\\'5J <>>%w7==D JJT /..(&&uGaHrzT x, T loc, T scalezT yz>y = loc + scale * ((x <= 0.5) ? log(x + x): -log(x + x - 1.0))cupy_laplace_kernelc[R"X5n[R"X$5nUc [R"X5RnUR X45n[ R XQX%5 U$)zReturns an array of samples drawn from the laplace distribution. .. seealso:: - :func:`cupy.random.laplace` for full documentation - :meth:`numpy.random.RandomState.laplace` )rBrPrQrO_random_sample_rawr_laplace_kernelr0locrwr6r=rxs rlaplaceRandomState.laplaces^ll3& U* <>>#-33D  # #D 0##AE5rc[R"U5[R"U5p!Uc [R"X5Rn[R"X4S9nUR UR 5n[R"Xe5 SU- U- n[R"XUS9 [R"XRUS9 [R"XQUS9 U$)zReturns an array of samples drawn from the logistic distribution. .. seealso:: - :func:`cupy.random.logistic` for full documentation - :meth:`numpy.random.RandomState.logistic` rNrprJ) rBrPrQrOrCr8r6ropen_uniform_kernellogmultiplyadd)r0rrwr6r=rxr7s rlogisticRandomState.logistic$s\\#& U(;U <>>#-33D JJT /..($$W0 1WM  aA& Qrc&SSKJn [SX455(a(URXX45n[R "XfS9 U$UcSn[ U5nURS:Xa URnO URnURXsXAU5$)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!c3V# UHn[U[R5v M! g7fr )rhrBndarray).0args r (RandomState.lognormal..AsF z#t||,, s')rr) r#r"rsnormalrBexp_check_and_get_dtypechargenerateLogNormalgenerateLogNormalDoublerK)r0meansigmar6r=r"rxrGs r lognormalRandomState.lognormal7s 3 F F F F D5A HHQ H <D$U+ :: ++D11D$$TeDDrc[R"U5n[R"US:*5(a [S5e[R"US:5(a [S5eUc URn[R "X#S9nUR UR5n[R"XU5 U$)zReturns 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.0rN) rBrPrsrtrOrCr8r6rlogseries_kernelrs r logseriesRandomState.logseriesNs LLO 88AF  Z( ( 88AF  Z( ( <77D JJT /..(!!!a0rignoreg:0yE>choleskyc b [R"S5 [R"XS9n[R"X'S9nUc/nO+[ U[ [R 45(aU/nOUn[UR5S:wa [S5e[UR5S:wd URSURS:wa [S5eURSURS:wa [S 5e[USS5n U RURS5 US ;a [S 5eUS :waUS :waUS:wa [S5eUS :Xa=[RSS9 [RRU5n SSS5 O[RUS9 US:Xa [RRU5n OUS:XaO[RR#U5upU [R."[R0"U 55-n OUUS:XaO[RR'U5upnU [R."[R0"U 55-n SSS5 UR9U US9R;SURS5n[R*"W UR,5nUR,nX- n[=U 5UlU$![ Gai [RS S9 US:waUS:Xa?[RR#U5up[R$"X*:5(+n US:XaZ[RR'U5upn[R("[R*"UR,U -U5X%US9n W [R."[R0"W 55-n W (d4"S[65 O:[2R4"S[65 [RRU5n SSS5 GM!,(df  GN=ff=f!,(df  GN=f![ a [!S5ef=f!,(df  GN!=f)a Returns an array of samples drawn from the multivariate normal distribution. .. warning:: This function calls one or more cuSOLVER routine(s) which may yield invalid results if input conditions are not met. To detect these invalid results, you can set the `linalg` configuration to a value that is not `ignore` in :func:`cupyx.errstate` or :func:`cupyx.seterr`. .. seealso:: - :func:`cupy.random.multivariate_normal` for full documentation - :meth:`numpy.random.RandomState.multivariate_normal` z+cupy.random.RandomState.multivariate_normalr<Nr>zmean must be 1 dimensionalr;rz$cov must be 2 dimensional and squarez"mean and cov must have same length>svdeighrz1method 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're)r experimentalrBrPrhrirjlenrOrtlistappendrerrstaterrrrrsrallclosedotTsqrtabswarningsrRuntimeWarningstandard_normalrFtuple)r0rcovr6 check_validtolr.r=rO final_shapedecompsupsdvhrxs rmultivariate_normalRandomState.multivariate_normalfs HI||D.ll3, <E sDLL1 2 2FEE tzz?a 9: :  Na SYYq\SYYq\%ACD D ::a=CIIaL (AB B58n 4::a=) 4 4CE E ( "f$)? IKK & w/?![[11#6F0/4{3 A+!%!5!5c!:6)!%!1!1#!6!"TYYtxx{%;!;5%)[[__S%9 r!"TYYtxx{%;!;4  ', ! ..5gb$**Q-.H HHVQSS ! CC  $[#?x8!Z/%/)-)9)9#)>*.((1t8*<&<%-1[[__S-A r&*mmDHHRTTAXr4J47'M%&488A;)?%?F#& ( /9:H!J %MM+56DF&*[[%9%9#%>F'9888?0/J#A%'@AAA43s6Q48K=3R5%RRAR/R0AR=Q1D6QQ1Q4 Q- 'Q1*Q4-Q11Q44 RRR R.c[R"U5n[R"U5n[R"US:*5(a [S5e[R"US:5(a [S5e[R"US:5(a [S5eUR USU- U- U5nUR XTS9$)aReturns 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<)rBrPrsrtrpoisson)r0rZr[r6r=rUs rnegative_binomialRandomState.negative_binomials LLO LLO 88AF  X& & 88AE??W% % 88AE??W% % JJq1Q3'4 (||A|++rc8SSKJn [U5nUc [R"X5R nUR S:Xa URnO URn[U[R5(a@URXcUSS5n[R"XrUS9 [R"XqUS9 U$[U[R5(a+URXcUSU5n[R"XqUS9 U$URXcXAU5nU$)zReturns an array of normally distributed samples. .. seealso:: - :func:`cupy.random.normal` for full documentation - :meth:`numpy.random.RandomState.normal` rr!rrrpr)r#r"rrBrQrOrgenerateNormalgenerateNormalDoublerhrrKrr)r0rrwr6r=r"rGrxs rrRandomState.normals 3$U+ <>>#-33D :: ((D..D eT\\ * *%%d%cBA MM! * HHQ #  T\\ * *%%d%eDA HHQ #%%d%eDArc[R"U5nUc URnURX#5n[R"XDS9 [R "U*U- US9 US- $)zReturns an array of samples drawn from the pareto II distribution. .. seealso:: - :func:`cupy.random.pareto` for full documentation - :meth:`numpy.random.RandomState.pareto` rr>)rBrPrOrrrr0rSr6r=rxs rparetoRandomState.paretosX LLO <77D  # #D 0  !A11u rc[R"U5[R"U5p![R"US:*5(a [S5e[R"US:5(a [S5eUc [R"X5R n[R "X4S9nURUR5n[R"XXe5 U$)aReturns 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 < 0rN) rBrPrsrtrQrOrCr8r6rnoncentral_chisquare_kernel)r0ranoncr6r=rUr7s rnoncentral_chisquare RandomState.noncentral_chisquares<<#T\\$%7D 88B!G  Y' ' 88D1H  Z( ( <>>"+11D JJT /..(,,RwBrcT[R"U5[R"U5[R"U5p2n[R"US:*5(a [S5e[R"US:*5(a [S5e[R"US:5(a [S5eUc![R"XU5R n[R "XES9nURUR5n[R"XX7U5 U$)aReturns 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 <= 0rrN) rBrPrsrtrQrOrCr8r6rnoncentral_f_kernel)r0r}r~rr6r=rUr7s r noncentral_fRandomState.noncentral_fs LL e!4dll46H 88EQJ  \* * 88EQJ  \* * 88D1H  Z( ( <>>%5;;D JJT /..($$U4!Drc[R"U5nUc URn[R"X#S9nUR UR 5n[ R"XU5 U$)zReturns an array of samples drawn from the poisson distribution. .. seealso:: - :func:`cupy.random.poisson` for full documentation - :meth:`numpy.random.RandomState.poisson` rN)rBrPrOrCr8r6rpoisson_kernel)r0lamr6r=rUr7s rrRandomState.poisson9sUll3 <99D JJT /..(a0rcL[R"U5n[R"US:5(a [S5eUc URnUR X#S9n[R "U*US9 [R"SU*US9 [R"USU- US9 U$)zReturns 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 < 0r6r=rr>rp) rBrPrsrtrOrurrpowerrs rrRandomState.powerHs LLO 88AE??W% % <77D  % %4 % = ! QBA 1bd"rcURS[5nU(a+[SSRUR 55-5eUR XS9$)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)popr TypeErrorjoinkeys random_sampler0r6kwargr=s rrandRandomState.rand^sR '5) H"ii 567 7!!t!99rcURS[5nU(a+[SSRUR 55-5eUR XS9$)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 rrandnRandomState.randnlsO '5) I"ii 567 7{{{22rzT xzx = (x == (T)1) ? 0 : xcupy_random_x_mod_1cTSSKJn [U5n[R"XS9nUR S:Xa UR nO URnUR U"URURRUR5 SSS5 U$!,(df  U$=f)Nrr!r<r) r#r"rrBrCrgenerateUniformgenerateUniformDoubler'r)rDrEr6)r0r6r=r"rJrGs rrRandomState._random_sample_raw}sy2$U+jj+ :: ))D//D ZZ #((,, 9 Z s 3B B'c\UcSnURX5n[RU5 U$)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` r)rr _mod1_kernel)r0r6r=rJs rrRandomState.random_samples1 <D%%d2  % rcj[R"U5nUc URn[R"US:5(a [ S5eUR X#5n[R "XDS9n[R"USUS9n[R"XDS9n[R"XAUS9nU$)zReturns 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` rrrrg) rBrPrOrsrtrrrrrvs rrayleighRandomState.rayleighs U# <;;D 88EAI  [) )  # #D 0 HHQ  MM!Sa ( IIa  MM! *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_modulochUcSnO[U[5(aU4n[R"U5nU(aUS:Xa#[R "U[R S9$US:a[SRU55eU[::a'[R nU"[SUS--- 5nGO.U[::a&[RnU"[SUS--- 5nO[S RU55eURnU[R:XdU[R :Xa7[R nURUS S 9nUR[U5nOyU[R :XdU[R:Xa7[RnURUS S 9nUR[U5nO[S RU55e["R$"[&R(US5nUS:Xa[R*"X$S9$UR-Xd5nU(aJUS-nUSUR/5S- -:Xa+SUR/5-S- n Xy-nUR1U5$UR3XuS 5n U R4n U S:a[R"U5(dXZnU S:aU(a[7U S -S5O UR4n UR-X5n UR3XS5nUR4nX:a XSU Xz'Sn OXXzSU'XSn U(dX_SnX-n U S:aMU(aUW-nOAU[R :XaUR9[X5nOUR9[X5nUR1U5$)aGenerate 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)rhrinumpyisscalarrBzerosuint32rtformat _UINT32_MAXr5uint64r=int32astype_interval_upper_limitint64 functoolsreduceoperatormulrC_curand_generate bit_lengthrF _get_indicesr6max_interval_sample_modulo)r0mxr6 is_mx_scalarr= upper_limitn_samplesamplemx1mask ng_indicesn_ng n_supplement supplement ok_indicesn_oks r _intervalRandomState._intervalsU <D c " "5D~~b) Qwzz$ell;;Av :AA"EGG{" #K7rAv2F$FG {" #K7rAv2F$FG  AHHLNNHHE "et{{&: YYu5Y1"88bI $**$(< YYu5Y1"88bI  4;;EBDD##HLL$: q=::d0 0&&x7 q&CaCNN,q011R]]_,1~~d++&&vEB  !8ENN2..%1KQh+ q$/1<1A1A ..|CJ**:DIJ??D|%/5D0A%B",6,B%4()'. #"-e"4K %Qh(  cMF dkk !11+rJF11+rJF~~d##rc<SSKJn [R"U4US9nUR [ R S9RnUR URURURRU5 SSS5 U$!,(df  U$=f)Nrr!r<) r#r"rBrCviewrrr6r'generater)rDrE)r0numr=r"r3size32s rr*RandomState._curand_generatesk2SF%05<<055 ZZ OODOOV[[__f E Z s 2B  Bc&URS:a[RO[RnU(aX:*OX:n[R "XTS9nA[R "[US54US9nURXgURS9 U$)Nrr<rer6) r6rrr!rBcumsumrCri_kernel_get_indices)r0r3r1condr=flagscsumindicess rr,RandomState._get_indices&ss & e 3 +/&f6J{{5. **c$r(m-U;   TYY ?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_indicescRSSKJn Uc8[R"[R "S55n[ US5nO[U[R5(a1[ [R"USS9R5SSS5nO][R "U5nUR"R$S ;a ['S 5e[ U5nUS:dUS :a [)S 5eUR* UR-UR.U5 UR0UR2UR44;aUR7UR.S5 XlSSS5 g![a" [R"5S-[-nNf=f!,(df  g=f) 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)r#r"binasciihexlifyosurandomriNotImplementedErrortimer5rhrrhashlibmd5 hexdigestrPr=kindrrtr'setPseudoRandomGeneratorSeedr)r.CURAND_RNG_PSEUDO_MT19937CURAND_RNG_PSEUDO_MTGP32setGeneratorOffsetr4)r0r/r"seed_strseed_arrs rr/RandomState.seed8s\ 3 < =#++BJJqM:8R($ ..7;;%11:SbBCEG!==.>>&&e3#$>??8}!8tu}$IKKZZ  / / F F$D$D$*$C$C$EE))$//1= M Z!' = g-< = Zs6E);A%F))FF F&ctURXS9n[R"[RUS- -5$)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?)uniformrBtanpir0r6r=rxs rstandard_cauchyRandomState.standard_cauchy]s0 LLdL 0xx1s7+,,rcXUcSnURX5n[R"X3S9*$)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` rr)rrBrrhs rru RandomState.standard_exponentialgs0 <D  # #D 0"""rc[R"U5nUc URn[R"X#S9nUR UR 5n[ R"XU5 U$)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` rN)rBrPrOrCr8r6rrk)r0rOr6r=rUr7s rstandard_gammaRandomState.standard_gammassU U# <;;D JJT /..(&&uq9rc URXS9$)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)r0r6r=s rrRandomState.standard_normals{{{22rc[R"U5nUc URn[R"X#S9nUR UR 5n[ R"XU5 U$)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` rN)rBrPrOrCr8r6rstandard_t_kernelr`s r standard_tRandomState.standard_tsU\\"  <88D JJT /..(""22rcSSKJn UcSn[R"U[RS9nUR R S-nUR URURURRURU-5 SSS5 U[R"[R5R-nU$!,(df  NA=f)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<)r#r"rBrCint_r=itemsizer'r@r)rDrEr6iinfor-)r0r6r"r3 size_in_ints rtomaxintRandomState.tomaxints" 3 <DD 2ll++q0 ZZ OO&++ 2K M $**TYY'+++ Zs ?C CzL 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_kernelc[R"U5[R"U5[R"U5p2n[R"X:5(a [S5e[R"X#:5(a [S5e[R"X:H5(a [S5eUc![R"XU5R nUR XES9n[RXX65$)zReturns 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 == rightr) rBrPrsrtrQrOrr_triangular_kernel)r0leftmoderightr6r=rxs r triangularRandomState.triangulars LL  T 2DLL4G 88DK ]+ + 88DL ! !^, , 88DM " "_- - <>>$e4::D   D  6--d%CCrz T low, T highzx = T(low) + x * T(high - low) cupy_scalec[R"U5(d[R"X5n[R"U5(d[R"X$5nUc [R"X5R n[R "U5nURX4S9n[RXU5$)zReturns an array of uniformly-distributed samples over an interval. .. seealso:: - :func:`cupy.random.uniform` for full documentation - :meth:`numpy.random.RandomState.uniform` r) rrrBrPrQrOr=rr _scale_kernel)r0lowhighr6r=rs rreRandomState.uniforms~~c"",,s*C~~d##<<,D <>>#,22D E"!!t!9((D99rc.[R"U5[R"U5p!Uc [R"X5Rn[R"X4S9nUR UR 5n[R"XXe5 U$)zReturns an array of samples drawn from the von Mises distribution. .. seealso:: - :func:`cupy.random.vonmises` for full documentation - :meth:`numpy.random.RandomState.vonmises` rN) rBrPrQrOrCr8r6rvonmises_kernel)r0mukappar6r=rUr7s rvonmisesRandomState.vonmisesskLL$dll5&9E <>>",22D JJT /..(  G7rzT 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[R"XS9[R"X$S9p!Uc [R"X5RnUR X4S9nUR X4S9n[ RXXe5$)zReturns an array of samples drawn from the Wald distribution. .. seealso:: - :func:`cupy.random.wald` for full documentation - :meth:`numpy.random.RandomState.wald` r<r)rBrPrQrOrrr _wald_kernel)r0rrwr6r=rxrs rwaldRandomState.wald so LL +T\\%-M <>>$.44D KKTK /   D  6''Q::rc[R"U5n[R"US:5(a [S5eUc URnUR X#5n[R "USU- US9 U$)zReturns 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` rrrpr)rBrPrsrtrOrurrs rweibullRandomState.weibull/sd LLO 88AE??W% % <77D  % %d 2 1bd"rc.[R"U5n[R"US:*5(a [S5eUc URn[R "X#S9nUR UR5n[R"XU5 U$)zReturns 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` rpz'a' must be a valid float > 1.0rN) rBrPrsrtrOrCr8r6r zipf_kernel)r0rSr6r=rUr7s rzipfRandomState.zipfEss LLO 88AH  @A A <77D JJT /..(Q+rcUc [S5e[U[R5(aURS:Xa[ e[U[ 5(aUnUS:a [S5eO;[R"USS9nURS:wa [S5e[U5nUb[R"U5nURS:wa [S5e[U5U:wa [S 5eUS:R5(d [S 5e[R"U5R5n[R"US5(d [S 5eUc [ S 5eUn[RR!U5nUS:XaUS:a [S 5eU(dUcXR:a [S5e[U[ 5(a[$R&nUR)U5n [R*R-U 5n U R/S[0S-U[R2S9n [%X[5n U "U5n U R5U5$UR75n UR9U 5 U SUR5U5$U(d[ eUb9UR;5nXS-nUR=U5nUR?USS9nO6US:XaSnURASXWS9nURC[RDSS9n[U[ 5(aU$URS:Xa"[R"UUURFS9$UU$!["a GNf=f)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'rrer)siderEr<)$rtrhrBrndimrWriarrayrallrlgetrrrr@rArr num_roundsr8random default_rngintegersr rrFrshufflerFr searchsortedrandintr#r%r=)r0rSr6replacer[a_sizep_sumrOn_roundsr7rngr bijectionrKcdfuniform_samplesindexs rchoiceRandomState.choiceZs 9DE E a & &166Q;% % a  Fz !GHH 15)Avv{ !HIIVF = 1 Avv{ !:;;1v !>??F<<>> !EFFHHQKOO%E>>%++ !@AA <%GI I >>&&u-D Q;4!8LM M19} ())!S!!+66..2ll..w7||{QXU\\$K,V: #D/u--&&( W%u~--e44% % =((*C r7NC"007O$$_7$CE{LLFL7ELL%L8E a  L ::?::ahagg6 6xe   s5M'' M54M5c[U[R5(d [S5eURS:Xa [S5eXR [ U55USS&g)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)rhrBrrr _permutationrr0rSs rrRandomState.shufflesS!T\\**<= = 66Q;GH H""3q6*+!rc[U[5(aURU5$XR[U55$)z6Returns a permuted range or a permutation of an array.)rhrirrrs r permutationRandomState.permutations8 a  $$Q' '&&s1v./ /rc4SSKJn [R"U4[R S9nUR  URURURRU5 SSS5 [R"U5nU$!,(df  N&=f)zReturns a permuted range.rr!r<N) r#r"rBrCrr"r'r@r)rDrEargsort)r0rAr"r3rs rrRandomState._permutations^2SF%++6 ZZ OODOOV[[__c B V$ Zs 2B  Bz$y = T(loc) - log(-log(x)) * T(scale)cupy_gumbel_kernelcZ[R"U5(d[R"X5n[R"U5(d[R"X$5nUc [R"X5R nUR X4S9n[RXQX%5 U$)zReturns an array of samples drawn from a Gumbel distribution. .. seealso:: - :func:`cupy.random.gumbel` for full documentation - :meth:`numpy.random.RandomState.gumbel` r) rrrBrPrQrOrr_gumbel_kernelrs rgumbelRandomState.gumbels~~c"",,s*C~~e$$LL.E <>>#-33D  # # # ;""154rc[R"U5(Gd [R"U5nUc[R"U5nUS- nOUn[R"U5S- nUc [R "XV5R nXe- n[R"[RUS5nURUR5U5n U RU5n [R"X5n URUSS9n[R"XU S9 U $UcSn[!U5S- n O[!U5n[!U5S- n XZ:a [#S5eU[R$"U5R&:a8[#SR)[R*"U5R,55eU [R$"U5R.:a8[#SR)[R*"U5R,55eX- nURXs5RUSS9n [R"XU S9 U $) 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` r>Frrrz low >= highzlow is out of bounds for {}zhigh is out of bounds for {})rrrBrP zeros_likerQrOr&r'r(r)r<flattenr#rFrrirtrzminrr=rr-) r0rrr6r=lohidiff total_elemsrJhi1rxs rrRandomState.randints~~c"",,s#C|__S)1W\\$'!+|~~b-337D#**8<<qAK..=C**U#C,,s)C5u-B HHS# &J|#hlX$i!mx //DJJu%))) 188 5)..011TZZ&*** 299 5)..0118Dt*11%e1DA HHQ "Hr)r-r)r'r4r.)NN)Nl)rpNrr )NTN)F__name__ __module__ __qualname____firstlineno____doc__r1r8rKrrVrir\rbrnryrrrrrElementwiseKernelrrrrrrrrrrrrrrrrrrrr$r.r<r*r,rGr/rirurnrrtr|rrrrerrrrrrrrrrrr__static_attributes__rrrrr.s-4  4*#% #'c "&U %)(!$$e($(u "%4u 0--uHO St5 cE&!$eE.037H %j^@,0s,,Cd%8" 37e0594 !, : 3** E,.CEL "&U !t5."33w=*, $55z.,. a$F 11o #!J$(u-)-E #*.U $(u3#'e @00!5 " !',26UD0++(M Cd%:((,5 **   L&* ;#%, s*Zx, 0,,u.N Cd%"!%4s1rrc6[5RU5 g)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/)r/s rr/r/!sD!rc0qgr )_random_statesrrr reset_statesr7s Nrc<[R"5n[RURS5nUcc[ R "S5nUb[R"[U55n[U5n[RURU5nU$)a<Gets 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) rDevicerridrUgetenvrr!rir setdefault)devrsr/s rrr=su ++-C   CFFD )B zyy%  <<D *D    & &svvr 2 Irc[U[5(d#[SR[ U555eU[ [ R"5'g)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)rhrrrtyperr get_device_id)rs rset_random_staterTsF b+ & & R)+ +.0N6'')*rch[R"U5nURS;a [S5eU$)N)rdz-cupy.random only supports float32 and float64)rr=rrr<s rrras- KK E zz#GHH Lrr )' __future__ratexitrSr&rYr(rUrXr%r*rr numpy.linalgrrBrr cupy.cudar cupy.randomrcupy.random._generator_apir r r rrrr r5rr/rregisterrrrrrrrrs"   $  7  G  ppf'"& . 0r