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)