def wald(mean, scale, size=None):
"""Wald distribution.
Draw samples from a Wald, or inverse Gaussian, distribution.
For full documentation refer to :obj:`numpy.random.wald`.
Limitations
-----------
Parameters ``mean`` and ``scale`` are supported as scalar.
Otherwise, :obj:`numpy.random.wald(mean, scale, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
>>> loc, scale = 3., 2.
>>> s = dpnp.random.wald(loc, scale, 1000)
"""
if not use_origin_backend(mean):
# TODO:
# array_like of floats for `mean` and `scale`
if not dpnp.isscalar(mean):
pass
elif not dpnp.isscalar(scale):
pass
elif mean <= 0:
pass
elif scale <= 0:
pass
else:
return dpnp_rng_wald(mean, scale, size).get_pyobj()
return call_origin(numpy.random.wald, mean, scale, size)
def laplace(loc=0.0, scale=1.0, size=None):
"""Laplace distribution.
Draw samples from the Laplace or double exponential distribution with
specified location (or mean) and scale (decay).
For full documentation refer to :obj:`numpy.random.laplace`.
Limitations
-----------
Parameters ``loc`` and ``scale`` are supported as scalar.
Otherwise, :obj:`numpy.random.laplace(loc, scale, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
>>> loc, scale = 0., 1.
>>> s = dpnp.random.laplace(loc, scale, 1000)
"""
if not use_origin_backend(loc):
# TODO:
# array_like of floats for `loc` and `scale`
if not dpnp.isscalar(loc):
pass
elif not dpnp.isscalar(scale):
pass
elif scale < 0:
pass
else:
return dpnp_rng_laplace(loc, scale, size)
return call_origin(numpy.random.laplace, loc, scale, size)
def hypot(x1, x2, dtype=None, out=None, where=True, **kwargs):
"""
Given the "legs" of a right triangle, return its hypotenuse.
For full documentation refer to :obj:`numpy.hypot`.
Limitations
-----------
Parameters ``x1`` and ``x2`` are supported as either :obj:`dpnp.ndarray` or scalar.
Parameters ``dtype``, ``out`` and ``where`` are supported with their default values.
Keyword arguments ``kwargs`` are currently unsupported.
Otherwise the functions will be executed sequentially on CPU.
Input array data types are limited by supported DPNP :ref:`Data types`.
Examples
--------
>>> import dpnp as np
>>> x1 = 3 * np.ones(3)
>>> x2 = 4 * np.ones(3)
>>> out = np.hypot(x1, x2)
>>> [i for i in out]
[5.0, 5.0, 5.0]
"""
x1_is_scalar = dpnp.isscalar(x1)
x2_is_scalar = dpnp.isscalar(x2)
x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_strides=False)
x2_desc = dpnp.get_dpnp_descriptor(x2, copy_when_strides=False)
if x1_desc and x2_desc and not kwargs:
if not x1_desc and not x1_is_scalar:
pass
elif not x2_desc and not x2_is_scalar:
pass
elif x1_is_scalar and x2_is_scalar:
pass
elif x1_desc and x1_desc.ndim == 0:
pass
elif x2_desc and x2_desc.ndim == 0:
pass
elif dtype is not None:
pass
elif out is not None:
pass
elif not where:
pass
else:
out_desc = dpnp.get_dpnp_descriptor(
out) if out is not None else None
return dpnp_hypot(x1_desc, x2_desc, dtype, out_desc,
where).get_pyobj()
return call_origin(numpy.hypot,
x1,
x2,
dtype=dtype,
out=out,
where=where,
**kwargs)
def gumbel(loc=0.0, scale=1.0, size=None):
"""Gumbel distribution.
Draw samples from a Gumbel distribution.
For full documentation refer to :obj:`numpy.random.gumbel`.
Limitations
-----------
Parameters ``loc`` and ``scale`` are supported as scalar.
Otherwise, :obj:`numpy.random.gumbel(loc, scale, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> mu, beta = 0, 0.1 # location and scale
>>> s = dpnp.random.gumbel(mu, beta, 1000)
"""
if not use_origin_backend(loc):
# TODO:
# array_like of floats for `loc` and `scale` params
if not dpnp.isscalar(scale):
pass
elif not dpnp.isscalar(loc):
pass
elif scale < 0:
pass
else:
return dpnp_rng_gumbel(loc, scale, size).get_pyobj()
return call_origin(numpy.random.gumbel, loc, scale, size)
def f(dfnum, dfden, size=None):
"""F distribution.
Draw samples from an F distribution.
For full documentation refer to :obj:`numpy.random.f`.
Limitations
-----------
Parameters ``dfnum`` and ``dfden`` are supported as scalar.
Otherwise, :obj:`numpy.random.f(dfnum, dfden, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
>>> dfnum, dfden = 3., 2.
>>> s = dpnp.random.f(dfnum, dfden, size)
"""
if not use_origin_backend(dfnum):
# TODO:
# array_like of floats for `dfnum` and `dfden`
if not dpnp.isscalar(dfnum):
pass
elif not dpnp.isscalar(dfden):
pass
elif dfnum <= 0:
pass
elif dfden <= 0:
pass
else:
return dpnp_rng_f(dfnum, dfden, size)
return call_origin(numpy.random.f, dfnum, dfden, size)
def normal(loc=0.0, scale=1.0, size=None):
"""Normal distribution.
Draw random samples from a normal (Gaussian) distribution.
For full documentation refer to :obj:`numpy.random.normal`.
Limitations
-----------
Parameters ``loc`` and ``scale`` are supported as scalar.
Otherwise, :obj:`numpy.random.normal(loc, scale, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> mu, sigma = 0, 0.1 # mean and standard deviation
>>> s = dpnp.random.normal(mu, sigma, 1000)
"""
if not use_origin_backend(loc):
# TODO:
# array_like of floats for `loc` and `scale` params
if not dpnp.isscalar(loc):
pass
elif not dpnp.isscalar(scale):
pass
elif scale < 0:
pass
else:
return dpnp_rng_normal(loc, scale, size)
return call_origin(numpy.random.normal, loc, scale, size)
def lognormal(mean=0.0, sigma=1.0, size=None):
"""Lognormal distribution.
Draw samples from a log-normal distribution.
For full documentation refer to :obj:`numpy.random.lognormal`.
Limitations
-----------
Parameters ``mean`` and ``sigma`` are supported as scalar.
Otherwise, :obj:`numpy.random.lognormal(mean, sigma, size)` samples
are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> mu, sigma = 3., 1. # mean and standard deviation
>>> s = dpnp.random.lognormal(mu, sigma, 1000)
"""
if not use_origin_backend(mean):
# TODO:
# array_like of floats for `mean` and `sigma` params
if not dpnp.isscalar(mean):
pass
elif not dpnp.isscalar(sigma):
pass
elif sigma < 0:
pass
else:
return dpnp_rng_lognormal(mean, sigma, size)
return call_origin(numpy.random.lognormal, mean, sigma, size)
def noncentral_chisquare(df, nonc, size=None):
"""Noncentral chi-square distribution.
Draw samples from a noncentral chi-square distribution.
For full documentation refer to :obj:`numpy.random.noncentral_chisquare`.
TODO
"""
if not use_origin_backend(df):
# TODO:
# array_like of floats for `mean` and `scale`
if not dpnp.isscalar(df):
pass
elif not dpnp.isscalar(nonc):
pass
elif df <= 0:
pass
elif nonc < 0:
pass
else:
return dpnp_rng_noncentral_chisquare(df, nonc, size).get_pyobj()
return call_origin(numpy.random.noncentral_chisquare, df, nonc, size)
def random_integers(low, high=None, size=None):
"""
Random integers between `low` and `high`, inclusive.
For full documentation refer to :obj:`numpy.random.random_integers`.
Limitations
-----------
Parameters ``low`` and ``high`` are supported as scalar.
Otherwise, :obj:`numpy.random.random_integers(low, high, size)` samples
are drawn.
See Also
--------
:obj:`dpnp.random.randint`
"""
if not use_origin_backend(low):
if high is None:
high = low
low = 0
# TODO:
# array_like of floats for `low` and `high` params
if not dpnp.isscalar(low):
pass
elif not dpnp.isscalar(high):
pass
else:
return randint(low, int(high) + 1, size=size)
return call_origin(numpy.random.random_integers, low, high, size)
def randint(low, high=None, size=None, dtype=int):
"""
Return random integers from `low` (inclusive) to `high` (exclusive).
For full documentation refer to :obj:`numpy.random.randint`.
Limitations
-----------
Parameters ``low`` and ``high`` are supported as scalar.
Parameter ``dtype`` is supported only for `int` or :obj:`dpnp.float32`.
Otherwise, :obj:`numpy.random.randint(low, high, size, dtype)` samples
are drawn.
Examples
--------
Draw samples from the distribution:
>>> low, high = 3, 11 # low and high
>>> s = dpnp.random.randint(low, high, 1000, dtype=dpnp.int32)
See Also
--------
:obj:`dpnp.random.random_integers` : similar to `randint`, only for the closed
interval [`low`, `high`], and 1 is the
lowest value if `high` is omitted.
"""
if not use_origin_backend(low):
# TODO
# add to the limitations
if dtype is int:
_dtype = dpnp.int32
else:
_dtype = dpnp.dtype(dtype)
if high is None:
high = low
low = 0
# TODO:
# array_like of floats for `low` and `high` params
if not dpnp.isscalar(low):
pass
elif not dpnp.isscalar(high):
pass
elif int(low) >= int(high):
pass
elif _dtype is not dpnp.int32:
pass
else:
low = int(low)
high = int(high)
return dpnp_rng_uniform(low, high, size, _dtype)
return call_origin(numpy.random.randint, low, high, size, dtype)
def _check_nd_call(origin_func,
dpnp_func,
x1,
x2,
dtype=None,
out=None,
where=True,
**kwargs):
"""Choose function to call based on input and call chosen fucntion."""
x1_is_scalar = dpnp.isscalar(x1)
x2_is_scalar = dpnp.isscalar(x2)
x1_desc = dpnp.get_dpnp_descriptor(x1)
x2_desc = dpnp.get_dpnp_descriptor(x2)
if x1_desc and x2_desc and not kwargs:
if not x1_desc and not x1_is_scalar:
pass
elif not x2_desc and not x2_is_scalar:
pass
elif x1_is_scalar and x2_is_scalar:
pass
elif x1_desc and x1_desc.ndim == 0:
pass
elif x2_desc and x2_desc.ndim == 0:
pass
elif x1_desc and x2_desc and x1_desc.size != x2_desc.size:
pass
elif x1_desc and x2_desc and x1_desc.shape != x2_desc.shape:
pass
elif out is not None and not isinstance(out, dparray):
pass
elif dtype is not None:
pass
elif out is not None:
pass
elif not where:
pass
else:
return dpnp_func(x1_desc,
x2_desc,
dtype=dtype,
out=out,
where=where)
return call_origin(origin_func,
x1,
x2,
dtype=dtype,
out=out,
where=where,
**kwargs)
def multiply(x1, x2, **kwargs):
"""
Multiply arguments element-wise.
For full documentation refer to :obj:`numpy.multiply`.
Limitations
-----------
Parameters ``x1`` and ``x2`` are supported as :obj:`dpnp.ndarray`.
Keyword arguments ``kwargs`` are currently unsupported.
Otherwise the functions will be executed sequentially on CPU.
Input array data types are limited by supported DPNP :ref:`Data types`.
Parameters ``x1`` and ``x2`` are supported with equal sizes and shapes.
Examples
--------
>>> import dpnp as np
>>> a = np.array([1, 2, 3, 4, 5])
>>> result = np.multiply(a, a)
>>> [x for x in result]
[1, 4, 9, 16, 25]
"""
is_x1_dparray = isinstance(x1, dparray)
is_x2_dparray = isinstance(x2, dparray)
is_x1_scalar = dpnp.isscalar(x1)
is_x2_scalar = dpnp.isscalar(x2)
if not use_origin_backend(x1):
if kwargs:
pass
elif not (is_x1_dparray or is_x1_scalar):
pass
elif not (is_x2_dparray or is_x2_scalar):
pass
elif is_x1_scalar and is_x2_scalar:
pass
elif (is_x1_dparray and is_x2_dparray) and (x1.size != x2.size):
pass
elif (is_x1_dparray and is_x2_dparray) and (x1.shape != x2.shape):
pass
else:
if is_x1_scalar:
return dpnp_multiply(x2, x1)
else:
return dpnp_multiply(x1, x2)
return call_origin(numpy.multiply, x1, x2, **kwargs)
def multiply(x1, x2, out=None, where=True, **kwargs):
"""
Multiply arguments element-wise.
For full documentation refer to :obj:`numpy.multiply`.
Limitations
-----------
Parameters ``x1`` and ``x2`` are supported as :obj:`dpnp.ndarray`.
Keyword arguments ``kwargs`` are currently unsupported.
Otherwise the functions will be executed sequentially on CPU.
Input array data types are limited by supported DPNP :ref:`Data types`.
Parameters ``x1`` and ``x2`` are supported with equal sizes and shapes.
Examples
--------
>>> import dpnp as np
>>> a = np.array([1, 2, 3, 4, 5])
>>> result = np.multiply(a, a)
>>> [x for x in result]
[1, 4, 9, 16, 25]
"""
x1_is_scalar, x2_is_scalar = dpnp.isscalar(x1), dpnp.isscalar(x2)
x1_is_dparray, x2_is_dparray = isinstance(x1, dparray), isinstance(
x2, dparray)
if not use_origin_backend(x1) and not kwargs:
if not x1_is_dparray and not x1_is_scalar:
pass
elif not x2_is_dparray and not x2_is_scalar:
pass
elif x1_is_scalar and x2_is_scalar:
pass
elif x1_is_dparray and x1.ndim == 0:
pass
elif x2_is_dparray and x2.ndim == 0:
pass
elif x1_is_dparray and x2_is_dparray and x1.size != x2.size:
pass
elif x1_is_dparray and x2_is_dparray and x1.shape != x2.shape:
pass
elif out is not None and not isinstance(out, dparray):
pass
elif not where:
pass
else:
return dpnp_multiply(x1, x2, out, where)
return call_origin(numpy.multiply, x1, x2, out=out, where=where, **kwargs)
def hypergeometric(ngood, nbad, nsample, size=None):
"""Hypergeometric distribution.
Draw samples from a Hypergeometric distribution.
For full documentation refer to :obj:`numpy.random.hypergeometric`.
Limitations
-----------
Parameters ``ngood``, ``nbad`` and ``nsample`` are supported as scalar.
Otherwise, :obj:`numpy.random.hypergeometric(shape, scale, size)` samples
are drawn.
Output array data type is :obj:`dpnp.int32`.
Examples
--------
Draw samples from the distribution:
>>> ngood, nbad, nsamp = 100, 2, 10
# number of good, number of bad, and number of samples
>>> s = dpnp.random.hypergeometric(ngood, nbad, nsamp, 1000)
"""
if not use_origin_backend(ngood) and dpnp_queue_is_cpu():
# TODO:
# array_like of ints for `ngood`, `nbad`, `nsample` param
if not dpnp.isscalar(ngood):
pass
elif not dpnp.isscalar(nbad):
pass
elif not dpnp.isscalar(nsample):
pass
elif ngood < 0:
pass
elif nbad < 0:
pass
elif nsample < 0:
pass
elif ngood + nbad < nsample:
pass
elif nsample < 1:
pass
else:
m = int(ngood)
l = int(ngood) + int(nbad)
s = int(nsample)
return dpnp_rng_hypergeometric(l, s, m, size)
return call_origin(numpy.random.hypergeometric, ngood, nbad, nsample, size)
def geometric(p, size=None):
"""Geometric distribution.
Draw samples from the geometric distribution.
For full documentation refer to :obj:`numpy.random.geometric`.
Limitations
-----------
Parameter ``p`` is supported as a scalar.
Otherwise, :obj:`numpy.random.geometric(p, size)` samples are drawn.
Output array data type is :obj:`dpnp.int32`.
Examples
--------
Draw ten thousand values from the geometric distribution,
with the probability of an individual success equal to 0.35:
>>> z = dpnp.random.geometric(p=0.35, size=10000)
"""
if not use_origin_backend(p):
# TODO:
# array_like of floats for `p` param
if not dpnp.isscalar(p):
pass
elif p > 1 or p <= 0:
pass
else:
return dpnp_rng_geometric(p, size)
return call_origin(numpy.random.geometric, p, size)
def exponential(scale=1.0, size=None):
"""Exponential distribution.
Draw samples from an exponential distribution.
For full documentation refer to :obj:`numpy.random.exponential`.
Limitations
-----------
Parameter ``scale`` is supported as a scalar.
Otherwise, :obj:`numpy.random.exponential(scale, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> scale = .5 # alpha
>>> s = dpnp.random.exponential(scale, 1000)
"""
if not use_origin_backend(scale):
# TODO:
# array_like of floats for `scale`
if not dpnp.isscalar(scale):
pass
elif scale < 0:
pass
else:
return dpnp_rng_exponential(scale, size)
return call_origin(numpy.random.exponential, scale, size)
def weibull(a, size=None):
"""
Draw samples from a Weibull distribution.
For full documentation refer to :obj:`numpy.random.weibull`.
Limitations
-----------
Parameter ``a`` is supported as a scalar.
Otherwise, :obj:`numpy.random.weibull(a, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
>>> a = 5. # shape
>>> s = np.random.weibull(a, 1000)
"""
if not use_origin_backend(a):
# TODO:
# array_like of floats for `a` param
if not dpnp.isscalar(a):
pass
elif a < 0:
pass
else:
return dpnp_rng_weibull(a, size)
return call_origin(numpy.random.weibull, a, size)
def standard_gamma(shape, size=None):
"""Standard gamma distribution.
Draw samples from a standard Gamma distribution.
For full documentation refer to :obj:`numpy.random.standard_gamma`.
Limitations
-----------
Parameter ``shape`` is supported as a scalar.
Otherwise, :obj:`numpy.random.standard_gamma(shape, size)` samples
are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> shape = 2.
>>> s = dpnp.random.standard_gamma(shape, 1000000)
"""
if not use_origin_backend(shape) and dpnp_queue_is_cpu():
# TODO:
# array_like of floats for `shape`
if not dpnp.isscalar(shape):
pass
elif shape < 0:
pass
else:
return dpnp_rng_standard_gamma(shape, size)
return call_origin(numpy.random.standard_gamma, shape, size)
def standard_t(df, size=None):
"""Standard Student’s t distribution.
Draw samples from a standard Student’s t distribution with
df degrees of freedom.
For full documentation refer to :obj:`numpy.random.standard_t`.
Limitations
-----------
Parameter ``df`` is supported as a scalar.
Otherwise, :obj:`numpy.random.standard_t(df, size)` samples
are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> df = 2.
>>> s = dpnp.random.standard_t(df, 1000000)
"""
if not use_origin_backend(df) and dpnp_queue_is_cpu():
# TODO:
# array_like of floats for `df`
if not dpnp.isscalar(df):
pass
elif df <= 0:
pass
else:
return dpnp_rng_standard_t(df, size)
return call_origin(numpy.random.standard_t, df, size)
def rayleigh(scale=1.0, size=None):
"""Rayleigh distribution.
Draw samples from a Rayleigh distribution.
For full documentation refer to :obj:`numpy.random.rayleigh`.
Limitations
-----------
Parameter ``scale`` is supported as a scalar.
Otherwise, :obj:`numpy.random.rayleigh(scale, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> import numpy as np
>>> s = dpnp.random.rayleigh(1.0, 10000)
"""
if not use_origin_backend(scale):
# TODO:
# array_like of floats for `scale` params
if not dpnp.isscalar(scale):
pass
elif scale < 0:
pass
else:
return dpnp_rng_rayleigh(scale, size)
return call_origin(numpy.random.rayleigh, scale, size)
def zipf(a, size=None):
"""Zipf distribution.
Returns an array of samples drawn from the Zipf distribution.
For full documentation refer to :obj:`numpy.random.zipf`.
Limitations
-----------
Parameter ``a`` is supported as a scalar.
Otherwise, :obj:`numpy.zipf.weibull(a, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
>>> a = 2. # parameter
>>> s = np.random.zipf(a, 1000)
"""
if not use_origin_backend(a):
# TODO:
# array_like of floats for `a` param
if not dpnp.isscalar(a):
pass
elif a <= 1:
pass
else:
return dpnp_rng_zipf(a, size).get_pyobj()
return call_origin(numpy.random.zipf, a, size)
def fill_diagonal(x1, val, wrap=False):
"""
Fill the main diagonal of the given array of any dimensionality.
For full documentation refer to :obj:`numpy.fill_diagonal`.
Limitations
-----------
Parameter ``wrap`` is supported only with default values.
See Also
--------
:obj:`dpnp.diag_indices` : Return the indices to access the main diagonal of an array.
:obj:`dpnp.diag_indices_from` : Return the indices to access the main diagonal of an n-dimensional array.
"""
x1_desc = dpnp.get_dpnp_descriptor(x1, copy_when_strides=False)
if x1_desc:
if not dpnp.isscalar(val):
pass
elif wrap:
pass
else:
return dpnp_fill_diagonal(x1_desc, val)
return call_origin(numpy.fill_diagonal, x1, val, wrap, dpnp_inplace=True)
def chisquare(df, size=None):
"""Chi-square distribution
Draw samples from a chi-square distribution.
For full documentation refer to :obj:`numpy.random.chisquare`.
Limitations
-----------
Parameter ``df`` is supported as a scalar.
Otherwise, :obj:`numpy.random.chisquare(df, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
>>> dpnp.random.chisquare(2,4)
array([ 1.89920014, 9.00867716, 3.13710533, 5.62318272]) # random
"""
if not use_origin_backend(df) and dpnp_queue_is_cpu():
# TODO:
# array_like of floats for `df`
if not dpnp.isscalar(df):
pass
elif df <= 0:
pass
else:
# TODO:
# float to int, safe
return dpnp_rng_chisquare(int(df), size)
return call_origin(numpy.random.chisquare, df, size)
def power(a, size=None):
"""Power distribution.
Draws samples in [0, 1] from a power distribution with positive
exponent a - 1.
For full documentation refer to :obj:`numpy.random.power`.
Limitations
-----------
Parameter ``a`` is supported as a scalar.
Otherwise, :obj:`numpy.random.power(a, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> a = .5 # alpha
>>> s = dpnp.random.power(a, 1000)
"""
if not use_origin_backend(a):
# TODO:
# array_like of floats for `a`
if not dpnp.isscalar(a):
pass
elif a <= 0:
pass
else:
return dpnp_rng_power(a, size)
return call_origin(numpy.random.power, a, size)
def fill_diagonal(input, val, wrap=False):
"""
Fill the main diagonal of the given array of any dimensionality.
For full documentation refer to :obj:`numpy.fill_diagonal`.
Limitations
-----------
Parameter ``wrap`` is supported only with default values.
See Also
--------
:obj:`dpnp.diag_indices` : Return the indices to access the main diagonal of an array.
:obj:`dpnp.diag_indices_from` : Return the indices to access the main diagonal of an n-dimensional array.
"""
if not use_origin_backend(input):
if not isinstance(input, dparray):
pass
elif not dpnp.isscalar(val):
pass
elif wrap:
pass
else:
return dpnp_fill_diagonal(input, val)
return call_origin(numpy.fill_diagonal, input, val, wrap)
def poisson(lam=1.0, size=None):
"""Poisson distribution.
Draw samples from a Poisson distribution.
For full documentation refer to :obj:`numpy.random.poisson`.
Limitations
-----------
Parameter ``lam`` is supported as a scalar.
Otherwise, :obj:`numpy.random.poisson(lam, size)` samples are drawn.
Output array data type is :obj:`dpnp.int32`.
Examples
--------
Draw samples from the distribution:
>>> import numpy as np
>>> s = dpnp.random.poisson(5, 10000)
"""
if not use_origin_backend(lam):
# TODO:
# array_like of floats for `lam` param
if not dpnp.isscalar(lam):
pass
elif lam < 0:
pass
else:
return dpnp_rng_poisson(lam, size)
return call_origin(numpy.random.poisson, lam, size)
def pareto(a, size=None):
"""Pareto II or Lomax distribution.
Draw samples from a Pareto II or Lomax distribution with specified shape.
For full documentation refer to :obj:`numpy.random.pareto`.
Limitations
-----------
Parameter ``a`` is supported as a scalar.
Otherwise, :obj:`numpy.random.pareto(a, size)` samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> a = .5 # alpha
>>> s = dpnp.random.pareto(a, 1000)
"""
if not use_origin_backend(a):
# TODO:
# array_like of floats for `a`
if not dpnp.isscalar(a):
pass
elif a <= 0:
pass
else:
return dpnp_rng_pareto(a, size)
return call_origin(numpy.random.pareto, a, size)
def negative_binomial(n, p, size=None):
"""Negative binomial distribution.
Draw samples from a negative binomial distribution.
For full documentation refer to :obj:`numpy.random.negative_binomial`.
Limitations
-----------
Parameters ``n`` and ``p`` are supported as scalar.
Otherwise, :obj:`numpy.random.negative_binomial(n, p, size)` samples
are drawn.
Output array data type is :obj:`dpnp.int32`.
Examples
--------
Draw samples from the distribution:
A real world example. A company drills wild-cat oil
exploration wells, each with an estimated probability of
success of 0.1. What is the probability of having one success
for each successive well, that is what is the probability of a
single success after drilling 5 wells, after 6 wells, etc.?
>>> s = dpnp.random.negative_binomial(1, 0.1, 100000)
>>> for i in range(1, 11):
... probability = sum(s<i) / 100000.
... print(i, "wells drilled, probability of one success =", probability)
"""
if not use_origin_backend(n) and dpnp_queue_is_cpu():
# TODO:
# array_like of floats for `p` and `n` params
if not dpnp.isscalar(n):
pass
elif not dpnp.isscalar(p):
pass
elif p > 1 or p < 0:
pass
elif n <= 0:
pass
else:
return dpnp_rng_negative_binomial(n, p, size)
return call_origin(numpy.random.negative_binomial, n, p, size)
def binomial(n, p, size=None):
"""Binomial distribution.
Draw samples from a binomial distribution.
For full documentation refer to :obj:`numpy.random.binomial`.
Limitations
-----------
Output array data type is :obj:`dpnp.int32`.
Parameters ``n`` and ``p`` are supported as scalar.
Otherwise, :obj:`numpy.random.binomial(n, p, size)` samples are drawn.
Examples
--------
Draw samples from the distribution:
>>> n, p = 10, .5 # number of trials, probability of each trial
>>> s = dpnp.random.binomial(n, p, 1000)
# result of flipping a coin 10 times, tested 1000 times.
A real world example. A company drills 9 wild-cat oil exploration
wells, each with an estimated probability of success of 0.1. All nine
wells fail. What is the probability of that happening?
Let's do 20,000 trials of the model, and count the number that
generate zero positive results.
>>> sum(dpnp.random.binomial(9, 0.1, 20000) == 0)/20000.
# answer = 0.38885, or 38%.
"""
if not use_origin_backend(n) and dpnp_queue_is_cpu():
# TODO:
# array_like of floats for `p` param
if not dpnp.isscalar(n):
pass
elif not dpnp.isscalar(p):
pass
elif p > 1 or p < 0:
pass
elif n < 0:
pass
else:
return dpnp_rng_binomial(int(n), p, size)
return call_origin(numpy.random.binomial, n, p, size)
def triangular(left, mode, right, size=None):
"""Triangular distribution.
Draw samples from the triangular distribution over the interval
[left, right].
For full documentation refer to :obj:`numpy.random.triangular`.
Limitations
-----------
Parameter ``left``, ``mode`` and ``right`` are supported as scalar.
Otherwise, :obj:`numpy.random.triangular(left, mode, right, size)`
samples are drawn.
Output array data type is :obj:`dpnp.float64`.
Examples
--------
Draw samples from the distribution:
>>> df = 2.
>>> s = dpnp.random.triangular(-3, 0, 8, 1000000)
"""
if not use_origin_backend(left):
# TODO:
# array_like of floats for `left`, `mode`, `right`.
if not dpnp.isscalar(left):
pass
elif not dpnp.isscalar(mode):
pass
elif not dpnp.isscalar(right):
pass
elif left > mode:
pass
elif mode > right:
pass
elif left == right:
pass
else:
return dpnp_rng_triangular(left, mode, right, size)
return call_origin(numpy.random.triangular, left, mode, right, size)
