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)