o װi@sddlZddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl m Z ddl Z ddl m Z ddl mZddlmZddlmZddl mZddlZdZd ZGd d d eZdd d ZiaejddZddZddZddZdS)N) LinAlgError)_core)cuda)device)_kernels)_utilllc@s@eZdZdZdddZddZddZdefd d Zde fd d Z defd dZ defddZ ddefddZ defddZddefddZde fddZde fddZeddddZd ddefd!d"Zd ddefd#d$Zd ddefd%d&Zde fd'd(Zdd)d*d+efd,d-Zde fd.d/Zd ddefd0d1Zdefd2d3Zdefd4d5Zdefd6d7Zdde fd8d9Zdefd:d;Z dd?Z"ed@dAdBdCZ#dDdEZ$defdFdGZ%ddefdHdIZ&edJdKdLdMZ'edJdNdOdPZ(dQdRZ)dSdTZ*dUdVZ+edWdXdYdZZ,dd[d\Z-defd]d^Z.defd_d`Z/defdadbZ0defdcddZ1defdedfZ2ddgdhZ3edidAdjdkZ4defdldmZ5edndAdodpZ6d ddefdqdrZ7defdsdtZ8edudvdwdxZ9defdydzZ:defd{d|Z;de fd}d~ZddZ?ddZ@eddddZAd ddefddZBdde fddZCdS) 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 NcCsNddlm}|dur |j}|||_t||j|j|_||_ | |dS)Nrcurand) cupy_backends.cuda.libsr CURAND_RNG_PSEUDO_DEFAULTcreateGenerator _generatorweakreffinalizedestroyGenerator _finalizermethodseed)selfrrr rJ/home/ubuntu/.local/lib/python3.10/site-packages/cupy/random/_generator.py__init__8s   zRandomState.__init__cCs|j|t|_dSN)_rk_seed _UINT64_MAX)rsizerrr _update_seedCszRandomState._update_seedcGst|}tj|}|ddkr(tj||d}||j|jj|j g|R|Stj|df|d}||j|jj|j g|R|d| |S)Nrdtype) rget_sizeinternalprodcupyemptyrdataptrrreshape)rfuncrr args element_sizeoutrrr_generate_normalFs   zRandomState._generate_normalcC\t|t|}}|durt||j}tj||d}t|||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 broadcastr1r&r beta_kernelrrr)rabrr yrrrbetaY zRandomState.betacCr/)zReturns an array of samples drawn from the binomial distribution. .. seealso:: - :func:`cupy.random.binomial` for full documentation - :meth:`numpy.random.RandomState.binomial` Nr0) r%r2r3r1r&rbinomial_kernelrrrrnprr r7rrrbinomialhr9zRandomState.binomialcCFt|}|dur |j}tj||d}t||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` Nr0) r%r2r1r&rchisquare_kernelrrrrdfrr r7rrr chisquarew  zRandomState.chisquarecCst|}|dur |j}nt|ttjfr|f|j}n||j7}tj||d}t||j |||j ddd}| |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` Nr0T)axiskeepdims) r%r2r1 isinstanceintintegerr&rstandard_gamma_kernelrsumrr)ralpharr r7rrr dirichlets   zRandomState.dirichlet?cCsFt||}|dkrtd|dur|j}|||}||9}|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 < 0N)r%r2any ValueErrorr1standard_exponentialrscalerr xrrr exponentials  zRandomState.exponentialcCr/)zReturns an array of samples drawn from the f distribution. .. seealso:: - :func:`cupy.random.f` for full documentation - :meth:`numpy.random.RandomState.f` Nr0) r%r2r3r1r&rf_kernelrrr)rdfnumdfdenrr r7rrrfr9z RandomState.fcCsbt|t|}}|durt||j}tj||d}t||j|||9}||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` Nr0) r%r2r3r1r&rrKrrr)rr1rUrr r7rrrgammas zRandomState.gammacCr?)zReturns an array of samples drawn from the geometric distribution. .. seealso:: - :func:`cupy.random.geometric` for full documentation - :meth:`numpy.random.RandomState.geometric` Nr0) r%r2r1r&rgeometric_kernelrrrrr=rr r7rrr geometricrDzRandomState.geometriccCslt|t|t|}}}|durt|||j}tj||d}t||||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` Nr0) r%r2r3r1r&rhypergeometric_kernelrrr)rngoodnbadnsamplerr r7rrrhypergeometrics zRandomState.hypergeometriczT x, T loc, T scalezT yz>y = loc + scale * ((x <= 0.5) ? log(x + x): -log(x + x - 1.0))cupy_laplace_kernelcCsNt||}t||}|durt||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` N)r%r2r3r1_random_sample_rawr_laplace_kernelrlocrUrr rVrrrlaplaces   zRandomState.laplacecCst|t|}}|durt||j}tj||d}t|j|||j d||}tj ||dtj |||dtj |||d|S)zReturns an array of samples drawn from the logistic distribution. .. seealso:: - :func:`cupy.random.logistic` for full documentation - :meth:`numpy.random.RandomState.logistic` Nr0rOr-) r%r2r3r1r&ropen_uniform_kernelrrrlogmultiplyaddrirrrlogistics  zRandomState.logisticcCsddlm}tdd||fDr"|||||}tj||d|S|dur(d}t|}|jdkr5|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 css|] }t|tjVqdSr)rHr%ndarray).0argrrr sz(RandomState.lognormal..rlNrr[) r r rQnormalr%exp_check_and_get_dtypechargenerateLogNormalgenerateLogNormalDoubler.)rmeansigmarr r rVr*rrr lognormals  zRandomState.lognormalcCsrt|}t|dkrtdt|dkrtd|dur"|j}tj||d}t||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.0Nr0) r%r2rQrRr1r&rlogseries_kernelrrrr^rrr logseries*s  zRandomState.logseriesignoreg:0yE>choleskyc Cs>tdtj||d}tj||d}|durg}nt|ttjfr&|g}n|}t|jdkr3t dt|jdksD|jd|jdkrHt d|jd|jdkrVt d t |dd} | |jd|d vrnt d |d kr~|d kr~|dkr~t d|d krt j ddztj|} Wnvtyt j d d]|dkr|dkrtj|\} } t| | k } |dkrtj|\} } }tjt|j| ||||d} | tt| } | stdtn tdttj|} Wdn 1swYYnwWdn 1swYnbt j |dSz>|dkr.tj|} n0|dkrFtj|\} } | tt| } n|dkr^tj|\} } }| tt| } Wn tyktdwWdn 1swwY|j| |dd|jd}t| |j}|j}||7}t| |_|S)aeReturns 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_normalrNr!zmean must be 1 dimensionalrrz$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 experimentalr%r2rHrIrJlenr1rRlistappendcupyxerrstaterrrrrQrallclosedotTsqrtabswarningsrRuntimeWarningstandard_normalr)tuple)rr|covr check_validtolrr r1 final_shapedecompsupsdvhrVrrrmultivariate_normalBs "      zRandomState.multivariate_normalcCszt|}t|}t|dkrtdt|dkr tdt|dkr+td||d|||}|j||dS)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%r2rQrRr\poissonr;rrrnegative_binomials zRandomState.negative_binomialcCsddlm}t|}|durt||j}|jdkr|j}n|j}t |tj rB| |||dd}tj |||dtj |||d|St |tj r[| |||d|}tj |||d|S| |||||}|S)zReturns an array of normally distributed samples. .. seealso:: - :func:`cupy.random.normal` for full documentation - :meth:`numpy.random.RandomState.normal` rr Nr[rfrOrl)r r rxr%r3r1rygenerateNormalgenerateNormalDoublerHrrr.rorp)rrjrUrr r r*rVrrrrvs$    zRandomState.normalcCsNt|}|dur |j}|||}tj||dtj| ||d|dS)zReturns an array of samples drawn from the pareto II distribution. .. seealso:: - :func:`cupy.random.pareto` for full documentation - :meth:`numpy.random.RandomState.pareto` Nrlr!)r%r2r1rgrnrwrr5rr rVrrrparetos  zRandomState.paretocCst|t|}}t|dkrtdt|dkr!td|dur,t||j}tj||d}t|||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 < 0Nr0) r%r2rQrRr3r1r&rnoncentral_chisquare_kernelrrr)rrBnoncrr r7rrrnoncentral_chisquares  z RandomState.noncentral_chisquarecCst|t|t|}}}t|dkrtdt|dkr'tdt|dkr2td|dur>t|||j}tj||d}t||||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 <= 0rNr0) r%r2rQrRr3r1r&rnoncentral_f_kernelrrr)rrYrZrrr r7rrr noncentral_fs  zRandomState.noncentral_fcCr?)zReturns an array of samples drawn from the poisson distribution. .. seealso:: - :func:`cupy.random.poisson` for full documentation - :meth:`numpy.random.RandomState.poisson` Nr0) r%r2r1r&rpoisson_kernelrrr)rlamrr r7rrrrrDzRandomState.poissoncCsvt|}t|dkrtd|dur|j}|j||d}tj| |dtjd| |dtj|d||d|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 < 0Nrr rlr!rO) r%r2rQrRr1rSrwrppowerrrrrr$s zRandomState.powercO4|dt}|rtdd||j||dS)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_samplerrkwargr rrrrand:  zRandomState.randcOr)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)rrrrrrvrrrrrandnHrzRandomState.randnzT xzx = (x == (T)1) ? 0 : xcupy_random_x_mod_1cCsRddlm}t|}tj||d}|jdkr|j}n|j}||j|j j |j |S)Nrr rr[) r r rxr%r&rygenerateUniformgenerateUniformDoublerr'r(r)rrr r r-r*rrrrgYs  zRandomState._random_sample_rawcCs&|durd}|||}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)rgr _mod1_kernel)rrr r-rrrres   zRandomState.random_samplecCszt|}|dur |j}t|dkrtd|||}tj||d}tj|d|d}tj||d}tj|||d}|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` NrrPrlg) r%r2r1rQrRrgrnrorrTrrrrayleighss  zRandomState.rayleighz 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_modulocCs|durd}nt|tr|f}t|}|rX|dkr"tj|tjdS|dkr-td||t kr?tj}|t d|d}nY|t krQtj }|t d|d}nGtd ||j }|tj kse|tjkrvtj}|j|d d }|t |}n"|tjks|tj krtj }|j|d d }|t |}ntd |ttj|d}|dkrtj||dS|||}|r|d}|d|d>krd|>d} || M}||S|||d } | j} | dkrt|s|| }| dkr=|rt| d dn|j} || |} || |d}|j}|| kr| |d| || <d} n| ||| d|<| |d} |s5||d}| |8} | dks|rE||;}n|tjkrS|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. Nrrrz$mx must be non-negative (actual: {})r!z+mx must be within uint64 range (actual: {})Fcopyzdtype must be integer, got: {}riT)rHrInumpyisscalarr%zerosuint32rRformat _UINT32_MAXruint64r int32astype_interval_upper_limitint64 functoolsreduceoperatormulr&_curand_generate bit_lengthr) _get_indicesrmax_interval_sample_modulo)rmxr is_mx_scalarr upper_limitn_samplesamplemx1mask ng_indicesn_ng n_supplement supplement ok_indicesn_okrrr _intervals            zRandomState._intervalcCsDddlm}tj|f|d}|jtjdj}||j |j j ||S)Nrr r) r r r%r&viewrrrgeneraterr'r()rnumr r rsize32rrrrs zRandomState._curand_generatecCsh|jdkrtjntj}|r||kn||k}tj||d}~tjt|df|d}|j|||jd|S)NrrrEr) rrrrr%cumsumr&rI_kernel_get_indices)rrrcondr flagscsumindicesrrrrszRandomState._get_indicesz 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_indicescCsddlm}|dur+zttd}t|d}WnGty*tdt }Yn7wt |t j rBtt j|ddddd}nt |}|jjd vrQtd t|}|dks]|d kratd ||j||j|j|jfvrx||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)r r binasciihexlifyosurandomrINotImplementedErrortimerrHrrrhashlibmd5 hexdigestr2r kindrrRsetPseudoRandomGeneratorSeedrrCURAND_RNG_PSEUDO_MT19937CURAND_RNG_PSEUDO_MTGP32setGeneratorOffsetr)rrr seed_strseed_arrrrrrs<       zRandomState.seedcCs"|j||d}ttj|dS)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%tanpirrr rVrrrstandard_cauchy7szRandomState.standard_cauchycCs(|durd}|||}tj||d 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` Nrrl)rgr%rnrrrrrSAs z RandomState.standard_exponentialcCr?)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` Nr0) r%r2r1r&rrKrrr)rr1rr r7rrrstandard_gammaMrDzRandomState.standard_gammacCs|j||dS)zReturns samples drawn from the standard normal distribution. .. seealso:: - :func:`cupy.random.standard_normal` for full documentation - :meth:`numpy.random.RandomState.standard_normal` r)rv)rrr rrrr\szRandomState.standard_normalcCr?)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` Nr0) r%r2r1r&rstandard_t_kernelrrrrArrr standard_tfrDzRandomState.standard_tcCsdddlm}|dur d}tj|tjd}|jjd}||j|j j |j ||t tjj M}|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)r r r%r&int_r itemsizerrr'r(riinfor)rrr r size_in_intrrrtomaxintus  zRandomState.tomaxintzL 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_kernelcCst|t|t|}}}t||krtdt||kr'tdt||kr2td|dur>t|||j}|j||d}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%r2rQrRr3r1rr_triangular_kernel)rleftmoderightrr rVrrr triangulars zRandomState.triangularz T low, T highzx = T(low) + x * T(high - low) cupy_scalecCsht|s t||}t|st||}|dur!t||j}t|}|j||d}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%r2r3r1r rr _scale_kernel)rlowhighrr rrrrrs     zRandomState.uniformcCr/)zReturns an array of samples drawn from the von Mises distribution. .. seealso:: - :func:`cupy.random.vonmises` for full documentation - :meth:`numpy.random.RandomState.vonmises` Nr0) r%r2r3r1r&rvonmises_kernelrrr)rmukapparr r7rrrvonmisesr9zRandomState.vonmiseszT 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_scalecCs`tj||dtj||d}}|durt||j}|j||d}|j||d}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` rNr)r%r2r3r1rvrr _wald_kernel)rr|rUrr rVrrrrwaldszRandomState.waldcCsRt|}t|dkrtd|dur|j}|||}tj|d||d|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` rrNrOrl)r%r2rQrRr1rSrrrrrweibulls  zRandomState.weibullcCs\t|}t|dkrtd|dur|j}tj||d}t||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` rOz'a' must be a valid float > 1.0Nr0) r%r2rQrRr1r&r zipf_kernelrrr)rr5rr r7rrrzipfs  zRandomState.zipfTc Cs0|durtdt|tjr|jdkrtt|tr%|}|dkr$tdntj|dd}|jdkr5tdt|}|durpt|}|jdkrKtdt||krUtd |dk s_td t | }t |dsptd |durxtd |}t |}|dkr|dkrtd |s|dur||krtdt|trtj|dd}n|}|||d||S|st|durt|||f}tjt||j||fddd} t|tst| |} n|dkrd}|jd||d} | jtjdd} t|tr| S| jdkrtj|| |jdS|| 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'lrr)rF)rRrHr%rrndimrrIarrayrallrLgetrrr$arangershuffler) broadcast_toargmaxrngumbelrandintrrr ) rr5rreplacer=a_sizep_sumr1rindexrrrchoice3s~                zRandomState.choicecCsDt|tjs td|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)rHr%rrrr2 _permutationrrr5rrrr7s  zRandomState.shufflecCs&t|tr ||S||t|S)z6Returns a permuted range or a permutation of an array.)rHrIrArrBrrr permutations  zRandomState.permutationcCs@ddlm}tj|ftjd}||j|jj |t |}|S)zReturns a permuted range.rr r) r r r%r&rrrrr'r(argsort)rrr rr3rrrrAs  zRandomState._permutationz$y = T(loc) - log(-log(x)) * T(scale)cupy_gumbel_kernelcCsdt|s t||}t|st||}|dur!t||j}|j||d}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%r2r3r1rgr_gumbel_kernelrirrrr:s    zRandomState.gumbelc Cstt|s\t|}|durt|}|d}n |}t|d}|dur,t||j}||}tt j |d}| | |} | |} t| |} |j |dd}tj| || d| S|durid}t|d} n t|}t|d} || kr{td|t|jkrtdt|j| t|jkrtd t|j| |}| ||j |dd} tj| || d| 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!Frrlrz low >= highzlow is out of bounds for {}zhigh is out of bounds for {})rrr%r2 zeros_liker3r1rrrrrflattenrr)rprIrRrminrr namer) rr%r&rr lohidiff total_elemsr-hi1rVrrrr;sP         zRandomState.randint)NNr)NTN)D__name__ __module__ __qualname____doc__rrr.rr8rIr>rCrNrWr[r\r_rdrElementwiseKernelrhrkrqr~rrrrvrrrrrrrrrgrrrrrrrrrrrSrrrrrr"r$rr*r,r-r.r0r@r7rCrArFr:r;rrrrrs   ` c   %     P rcCst|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)rrrrrsrcCsiadSr)_random_statesrrrr reset_statessrWcCsXt}t|jd}|dur*td}|durtt |}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) rDevicerVr5idrgetenvrrrIr setdefault)devrsrrrrrU s  rUcCs,t|tstdt||tt<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)rHrrrtyperVr get_device_id)r^rrrset_random_state s  racCs t|}|jdvrtd|S)N)r[dz-cupy.random only supports float32 and float64)rr ryrrrrrrx-s  rxr) atexitrrrrrrrrr numpy.linalgrr%rr cupy.cudar cupy.randomrrrrrobjectrrrVregisterrWrUrarxrrrrsJ       Z