def noncentral_f(dfnum, dfden, nonc, size=None, dtype=float): """Noncentral F distribution. Returns an array of samples drawn from the noncentral F distribution. Reference: https://en.wikipedia.org/wiki/Noncentral_F-distribution Args: dfnum (float): Parameter of the noncentral F distribution. dfden (float): Parameter of the noncentral F distribution. nonc (float): Parameter of the noncentral F distribution. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the noncentral F distribution. .. seealso:: :meth:`numpy.random.noncentral_f <numpy.random.mtrand.RandomState.noncentral_f>` """ rs = generator.get_random_state() return rs.noncentral_f(dfnum, dfden, nonc, size=size, dtype=dtype)
def pareto(a, size=None, dtype=float): """Pareto II or Lomax distribution. Returns an array of samples drawn from the Pareto II distribution. Its probability density function is defined as .. math:: f(x) = \\alpha(1+x)^{-(\\alpha+1)}. Args: a (float or array_like of floats): Parameter of the Pareto II distribution :math:`\\alpha`. size (int or tuple of ints): The shape of the array. If ``None``, this function generate an array whose shape is `a.shape`. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the Pareto II distribution. .. seealso:: :meth:`numpy.random.pareto <numpy.random.mtrand.RandomState.pareto>` """ rs = generator.get_random_state() x = rs.pareto(a, size, dtype) return x
def noncentral_chisquare(df, nonc, size=None, dtype=float): """Noncentral chisquare distribution. Returns an array of samples drawn from the noncentral chisquare distribution. Its probability density function is defined as .. math:: f(x) = \\frac{1}{2}e^{-(x+\\lambda)/2} \\ \\left(\\frac{x}{\\lambda}\\right)^{k/4 - 1/2} \\ I_{k/2 - 1}(\\sqrt{\\lambda x}), where :math:`I` is the modified Bessel function of the first kind. Args: df (float): Parameter of the noncentral chisquare distribution :math:`k`. nonc (float): Parameter of the noncentral chisquare distribution :math:`\\lambda`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the noncentral chisquare distribution. .. seealso:: :meth:`numpy.random.noncentral_chisquare <numpy.random.mtrand.RandomState.noncentral_chisquare>` """ rs = generator.get_random_state() return rs.noncentral_chisquare(df, nonc, size=size, dtype=dtype)
def logseries(p, size=None, dtype=int): """Log series distribution. Returns an array of samples drawn from the log series distribution. Its probability mass function is defined as .. math:: f(x) = \\frac{-p^x}{x\\ln(1-p)}. Args: p (float): Parameter of the log series distribution :math:`p`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.int32` and :class:`numpy.int64` types are allowed. Returns: cupy.ndarray: Samples drawn from the log series distribution. .. seealso:: :meth:`numpy.random.logseries <numpy.random.mtrand.RandomState.logseries>` """ rs = generator.get_random_state() return rs.logseries(p, size=size, dtype=dtype)
def negative_binomial(n, p, size=None, dtype=int): """Negative binomial distribution. Returns an array of samples drawn from the negative binomial distribution. Its probability mass function is defined as .. math:: f(x) = \\binom{x + n - 1}{n - 1}p^n(1-p)^{x}. Args: n (int): Parameter of the negative binomial distribution :math:`n`. p (float): Parameter of the negative binomial distribution :math:`p`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.int32` and :class:`numpy.int64` types are allowed. Returns: cupy.ndarray: Samples drawn from the negative binomial distribution. .. seealso:: :meth:`numpy.random.negative_binomial <numpy.random.mtrand.RandomState.negative_binomial>` """ rs = generator.get_random_state() return rs.negative_binomial(n, p, size=size, dtype=dtype)
def hypergeometric(ngood, nbad, nsample, size=None, dtype=int): """hypergeometric distribution. Returns an array of samples drawn from the hypergeometric distribution. Its probability mass function is defined as .. math:: f(x) = \\frac{\\binom{m}{n}\\binom{N-m}{n-x}}{\\binom{N}{n}}. Args: ngood (int or array_like of ints): Parameter of the hypergeometric distribution :math:`n`. nbad (int or array_like of ints): Parameter of the hypergeometric distribution :math:`m`. nsample (int or array_like of ints): Parameter of the hypergeometric distribution :math:`N`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.int32` and :class:`numpy.int64` types are allowed. Returns: cupy.ndarray: Samples drawn from the hypergeometric distribution. .. seealso:: :meth:`numpy.random.hypergeometric <numpy.random.mtrand.RandomState.hypergeometric>` """ rs = generator.get_random_state() return rs.hypergeometric(ngood, nbad, nsample, size, dtype)
def logistic(loc=0.0, scale=1.0, size=None, dtype=float): """Logistic distribution. Returns an array of samples drawn from the logistic distribution. Its probability density function is defined as .. math:: f(x) = \\frac{e^{-(x-\\mu)/s}}{s(1+e^{-(x-\\mu)/s})^2}. Args: loc (float): The location of the mode :math:`\\mu`. scale (float): The scale parameter :math:`s`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the logistic distribution. .. seealso:: :meth:`numpy.random.logistic <numpy.random.mtrand.RandomState.logistic>` """ rs = generator.get_random_state() return rs.logistic(loc, scale, size, dtype)
def f(dfnum, dfden, size=None, dtype=float): """F distribution. Returns an array of samples drawn from the f distribution. Its probability density function is defined as .. math:: f(x) = \\frac{1}{B(\\frac{d_1}{2},\\frac{d_2}{2})} \ \\left(\\frac{d_1}{d_2}\\right)^{\\frac{d_1}{2}} \ x^{\\frac{d_1}{2}-1} \ \\left(1+\\frac{d_1}{d_2}x\\right) \ ^{-\\frac{d_1+d_2}{2}}. Args: dfnum (float or array_like of floats): Parameter of the f distribution :math:`d_1`. dfden (float or array_like of floats): Parameter of the f distribution :math:`d_2`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the f distribution. .. seealso:: :meth:`numpy.random.f <numpy.random.mtrand.RandomState.f>` """ rs = generator.get_random_state() return rs.f(dfnum, dfden, size, dtype)
def geometric(p, size=None, dtype=int): """Geometric distribution. Returns an array of samples drawn from the geometric distribution. Its probability mass function is defined as .. math:: f(x) = p(1-p)^{k-1}. Args: p (float): Success probability of the geometric distribution. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.int32` and :class:`numpy.int64` types are allowed. Returns: cupy.ndarray: Samples drawn from the geometric distribution. .. seealso:: :func:`cupy.random.RandomState.geometric` :meth:`numpy.random.geometric <numpy.random.mtrand.RandomState.geometric>` """ rs = generator.get_random_state() return rs.geometric(p, size, dtype)
def exponential(scale, size=None, dtype=float): """Exponential distribution. Returns an array of samples drawn from the exponential distribution. Its probability density function is defined as .. math:: f(x) = \\frac{1}{\\beta}\\exp (-\\frac{x}{\\beta}). Args: scale (float or array_like of floats): The scale parameter :math:`\\beta`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the exponential distribution. .. seealso:: :meth:`numpy.random.exponential <numpy.random.mtrand.RandomState.exponential>` """ rs = generator.get_random_state() return rs.exponential(scale, size, dtype)
def choice(a, size=None, replace=True, p=None): """Returns an array of random values from a given 1-D array. Each element of the returned array is independently sampled from ``a`` according to ``p`` or uniformly. .. note:: Currently ``p`` is not supported when ``replace=False``. Args: a (1-D array-like or int): If an array-like, a random sample is generated from its elements. If an int, the random sample is generated as if ``a`` was ``cupy.arange(n)`` size (int or tuple of ints): The shape of the array. replace (boolean): Whether the sample is with or without replacement. p (1-D array-like): The probabilities associated with each entry in ``a``. If not given the sample assumes a uniform distribution over all entries in ``a``. Returns: cupy.ndarray: An array of ``a`` values distributed according to ``p`` or uniformly. .. seealso:: :meth:`numpy.random.choice <numpy.random.mtrand.RandomState.choice>` """ rs = generator.get_random_state() return rs.choice(a, size, replace, p)
def randint(low, high=None, size=None): """Returns a scalar or an array of integer values over ``[low, high)``. Each element of returned values are independently sampled from uniform distribution over left-close and right-open interval ``[low, high)``. Args: low (int): If ``high`` is not ``None``, it is the lower bound of the interval. Otherwise, it is the **upper** bound of the interval and lower bound of the interval is set to ``0``. high (int): Upper bound of the interval. size (None or int or tuple of ints): The shape of returned value. Returns: int or cupy.ndarray of ints: If size is ``None``, it is single integer sampled. If size is integer, it is the 1D-array of length ``size`` element. Otherwise, it is the array whose shape specified by ``size``. """ if high is None: lo = 0 hi = low else: lo = low hi = high if lo >= hi: raise ValueError('low >= high') diff = hi - lo - 1 rs = generator.get_random_state() return lo + rs.interval(diff, size)
def poisson(lam=1.0, size=None, dtype=int): """Poisson distribution. Returns an array of samples drawn from the poisson distribution. Its probability mass function is defined as .. math:: f(x) = \\frac{\\lambda^xe^{-\\lambda}}{k!}. Args: lam (array_like of floats): Parameter of the poisson distribution :math:`\\lambda`. size (int or tuple of ints): The shape of the array. If ``None``, this function generate an array whose shape is `lam.shape`. dtype: Data type specifier. Only :class:`numpy.int32` and :class:`numpy.int64` types are allowed. Returns: cupy.ndarray: Samples drawn from the poisson distribution. .. seealso:: :meth:`numpy.random.poisson <numpy.random.mtrand.RandomState.poisson>` """ rs = generator.get_random_state() x = rs.poisson(lam, size, dtype) return x
def chisquare(df, size=None, dtype=float): """Chi-square distribution. Returns an array of samples drawn from the chi-square distribution. Its probability density function is defined as .. math:: f(x) = \\frac{(1/2)^{k/2}}{\\Gamma(k/2)}x^{k/2-1}e^{-x/2}. Args: df (int or array_like of ints): Degree of freedom :math:`k`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the chi-square distribution. .. seealso:: :meth:`numpy.random.chisquare <numpy.random.mtrand.RandomState.chisquare>` """ rs = generator.get_random_state() return rs.chisquare(df, size, dtype)
def test_get_random_state_memoized(self): generator._random_states = {self.device_id: 'expected', self.device_id + 1: 'dummy'} rs = generator.get_random_state() self.assertEqual('expected', generator._random_states[self.device_id]) self.assertEqual('dummy', generator._random_states[self.device_id + 1]) self.assertEqual('expected', rs)
def laplace(loc=0.0, scale=1.0, size=None, dtype=float): """Laplace distribution. Returns an array of samples drawn from the laplace distribution. Its probability density function is defined as .. math:: f(x) = \\frac{1}{2b}\\exp\\left(-\\frac{|x-\\mu|}{b}\\right), Args: loc (float): The location of the mode :math:`\\mu`. scale (float): The scale parameter :math:`b`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the laplace destribution. .. seealso:: :func:`cupy.random.RandomState.laplace` :func:`numpy.random.laplace` """ rs = generator.get_random_state() return rs.laplace(loc, scale, size, dtype)
def permutation(a): """Returns a permuted range or shuffles an array.""" if isinstance(a, six.integer_types): rs = generator.get_random_state() return rs.permutation(a) else: return shuffle(a)
def gumbel(loc=0.0, scale=1.0, size=None, dtype=float): """Returns an array of samples drawn from a Gumbel distribution. The samples are drawn from a Gumbel distribution with location ``loc`` and scale ``scale``. Its probability density function is defined as .. math:: f(x) = \\frac{1}{\\eta} \ \\exp\\left\\{ - \\frac{x - \\mu}{\\eta} \\right\\} \ \\exp\\left[-\\exp\\left\\{-\\frac{x - \\mu}{\\eta} \ \\right\\}\\right], where :math:`\\mu` is ``loc`` and :math:`\\eta` is ``scale``. Args: loc (float): The location of the mode :math:`\\mu`. scale (float): The scale parameter :math:`\\eta`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the Gumbel destribution. .. seealso:: :func:`cupy.random.RandomState.gumbel` :func:`numpy.random.gumbel` """ rs = generator.get_random_state() return rs.gumbel(loc, scale, size, dtype)
def binomial(n, p, size=None, dtype=int): """Binomial distribution. Returns an array of samples drawn from the binomial distribution. Its probability mass function is defined as .. math:: f(x) = \\binom{n}{x}p^x(1-p)^{n-x}, Args: n (int): Trial number of the binomial distribution. p (float): Success probability of the binomial distribution. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.int32` and :class:`numpy.int64` types are allowed. Returns: cupy.ndarray: Samples drawn from the binomial destribution. .. seealso:: :func:`cupy.random.RandomState.binomial` :func:`numpy.random.binomial` """ rs = generator.get_random_state() return rs.binomial(n, p, size, dtype)
def weibull(a, size=None, dtype=float): """weibull distribution. Returns an array of samples drawn from the weibull distribution. Its probability density function is defined as .. math:: f(x) = ax^{(a-1)}e^{-x^a}. Args: a (float): Parameter of the weibull distribution :math:`a`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the weibull distribution. .. seealso:: :meth:`numpy.random.weibull <numpy.random.mtrand.RandomState.weibull>` """ rs = generator.get_random_state() return rs.weibull(a, size=size, dtype=dtype)
def zipf(a, size=None, dtype=int): """Zipf distribution. Returns an array of samples drawn from the Zipf distribution. Its probability mass function is defined as .. math:: f(x) = \\frac{x^{-a}}{ \\zeta (a)}, where :math:`\\zeta` is the Riemann Zeta function. Args: a (float): Parameter of the beta distribution :math:`a`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.int32` and :class:`numpy.int64` types are allowed. Returns: cupy.ndarray: Samples drawn from the Zipf distribution. .. seealso:: :meth:`numpy.random.zipf <numpy.random.mtrand.RandomState.zipf>` """ rs = generator.get_random_state() return rs.zipf(a, size=size, dtype=dtype)
def dirichlet(alpha, size=None, dtype=float): """Dirichlet distribution. Returns an array of samples drawn from the dirichlet distribution. Its probability density function is defined as .. math:: f(x) = \\frac{\\Gamma(\\sum_{i=1}^K\\alpha_i)} \ {\\prod_{i=1}^{K}\\Gamma(\\alpha_i)} \ \\prod_{i=1}^Kx_i^{\\alpha_i-1}. Args: alpha (array): Parameters of the dirichlet distribution :math:`\\alpha`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the dirichlet distribution. .. seealso:: :meth:`numpy.random.dirichlet <numpy.random.mtrand.RandomState.dirichlet>` """ rs = generator.get_random_state() return rs.dirichlet(alpha, size, dtype)
def wald(mean, scale, size=None, dtype=float): """Wald distribution. Returns an array of samples drawn from the Wald distribution. Its probability density function is defined as .. math:: f(x) = \\sqrt{\\frac{\\lambda}{2\\pi x^3}}\\ e^{\\frac{-\\lambda(x-\\mu)^2}{2\\mu^2x}}. Args: mean (float): Parameter of the wald distribution :math:`\\mu`. scale (float): Parameter of the wald distribution :math:`\\lambda`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the wald distribution. .. seealso:: :func:`cupy.random.RandomState.wald` :meth:`numpy.random.wald <numpy.random.mtrand.RandomState.wald>` """ rs = generator.get_random_state() return rs.wald(mean, scale, size, dtype)
def triangular(left, mode, right, size=None, dtype=float): """Triangular distribution. Returns an array of samples drawn from the triangular distribution. Its probability density function is defined as .. math:: f(x) = \\begin{cases} \\frac{2(x-l)}{(r-l)(m-l)} & \\text{for } l \\leq x \\leq m, \\\\ \\frac{2(r-x)}{(r-l)(r-m)} & \\text{for } m \\leq x \\leq r, \\\\ 0 & \\text{otherwise}. \\end{cases} Args: left (float): Lower limit :math:`l`. mode (float): The value where the peak of the distribution occurs. :math:`m`. right (float): Higher Limit :math:`r`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the triangular distribution. .. seealso:: :func:`cupy.random.RandomState.triangular` :meth:`numpy.random.triangular <numpy.random.mtrand.RandomState.triangular>` """ rs = generator.get_random_state() return rs.triangular(left, mode, right, size, dtype)
def vonmises(mu, kappa, size=None, dtype=float): """von Mises distribution. Returns an array of samples drawn from the von Mises distribution. Its probability density function is defined as .. math:: f(x) = \\frac{e^{\\kappa \\cos(x-\\mu)}}{2\\pi I_0(\\kappa)}. Args: mu (float): Parameter of the von Mises distribution :math:`\\mu`. kappa (float): Parameter of the von Mises distribution :math:`\\kappa`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the von Mises distribution. .. seealso:: :meth:`numpy.random.vonmises <numpy.random.mtrand.RandomState.vonmises>` """ rs = generator.get_random_state() return rs.vonmises(mu, kappa, size=size, dtype=dtype)
def standard_t(df, size=None, dtype=float): """Standard Student's t distribution. Returns an array of samples drawn from the standard Student's t distribution. Its probability density function is defined as .. math:: f(x) = \\frac{\\Gamma(\\frac{\\nu+1}{2})} \ {\\sqrt{\\nu\\pi}\\Gamma(\\frac{\\nu}{2})} \ \\left(1 + \\frac{x^2}{\\nu} \\right)^{-(\\frac{\\nu+1}{2})}. Args: df (float or array_like of floats): Degree of freedom :math:`\\nu`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the standard Student's t distribution. .. seealso:: :meth:`numpy.random.standard_t <numpy.random.mtrand.RandomState.standard_t>` """ rs = generator.get_random_state() return rs.standard_t(df, size, dtype)
def standard_gamma(shape, size=None, dtype=float): """Standard gamma distribution. Returns an array of samples drawn from the standard gamma distribution. Its probability density function is defined as .. math:: f(x) = \\frac{1}{\\Gamma(k)}x^{k-1}e^{-x}. Args: shape (array): Parameter of the gamma distribution :math:`k`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the standard gamma distribution. .. seealso:: :meth:`numpy.random.standard_gamma <numpy.random.mtrand.RandomState.standard_gamma>` """ rs = generator.get_random_state() return rs.standard_gamma(shape, size, dtype)
def beta(a, b, size=None, dtype=float): """Beta distribution. Returns an array of samples drawn from the beta distribution. Its probability density function is defined as .. math:: f(x) = \\frac{x^{\\alpha-1}(1-x)^{\\beta-1}}{B(\\alpha,\\beta)}. Args: a (float): Parameter of the beta distribution :math:`\\alpha`. b (float): Parameter of the beta distribution :math:`\\beta`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the beta distribution. .. seealso:: :meth:`numpy.random.beta <numpy.random.mtrand.RandomState.beta>` """ rs = generator.get_random_state() return rs.beta(a, b, size, dtype)
def rayleigh(scale=1.0, size=None, dtype=float): """Rayleigh distribution. Returns an array of samples drawn from the rayleigh distribution. Its probability density function is defined as .. math:: f(x) = \\frac{x}{\\sigma^2}e^{\\frac{-x^2}{2-\\sigma^2}}, x \\ge 0. Args: scale (array): Parameter of the rayleigh distribution :math:`\\sigma`. size (int or tuple of ints): The shape of the array. If ``None``, a zero-dimensional array is generated. dtype: Data type specifier. Only :class:`numpy.float32` and :class:`numpy.float64` types are allowed. Returns: cupy.ndarray: Samples drawn from the rayleigh distribution. .. seealso:: :meth:`numpy.random.rayleigh <numpy.random.mtrand.RandomState.rayleigh>` """ rs = generator.get_random_state() x = rs.rayleigh(scale, size, dtype) return x
def shuffle(a): """Shuffles an array. Args: a (cupy.ndarray): The array to be shuffled. .. seealso:: :func:`numpy.random.shuffle` """ rs = generator.get_random_state() return rs.shuffle(a)