def multinomial(n, pvals, size=None):
"""Returns an array from multinomial distribution.
Args:
n (int): Number of trials.
pvals (cupy.ndarray): Probabilities of each of the ``p`` different
outcomes. The sum of these values must be 1.
size (int or tuple of ints or None): Shape of a sample in each trial.
For example when ``size`` is ``(a, b)``, shape of returned value is
``(a, b, p)`` where ``p`` is ``len(pvals)``.
If ``size`` is ``None``, it is treated as ``()``. So, shape of
returned value is ``(p,)``.
Returns:
cupy.ndarray: An array drawn from multinomial distribution.
.. note::
It does not support ``sum(pvals) < 1`` case.
.. seealso:: :meth:`numpy.random.multinomial
<numpy.random.mtrand.RandomState.multinomial>`
"""
if size is None:
m = 1
size = ()
elif isinstance(size, int):
m = size
size = (size, )
else:
size = tuple(size)
m = 1
for x in size:
m *= x
p = len(pvals)
shape = size + (p, )
ys = basic.zeros(shape, 'l')
if ys.size > 0:
xs = choice(p, p=pvals, size=n * m)
_multinominal_kernel(xs, p, n, ys)
return ys
def __init__(self, arg1, shape=None, dtype=None, copy=False):
if shape is not None:
if not _util.isshape(shape):
raise ValueError('invalid shape (must be a 2-tuple of int)')
shape = int(shape[0]), int(shape[1])
if base.issparse(arg1):
x = arg1.asformat(self.format)
data = x.data
indices = x.indices
indptr = x.indptr
if arg1.format != self.format:
# When formats are differnent, all arrays are already copied
copy = False
if shape is None:
shape = arg1.shape
elif _util.isshape(arg1):
m, n = arg1
m, n = int(m), int(n)
data = basic.zeros(0, dtype if dtype else 'd')
indices = basic.zeros(0, 'i')
indptr = basic.zeros(self._swap(m, n)[0] + 1, dtype='i')
# shape and copy argument is ignored
shape = (m, n)
copy = False
elif scipy_available and scipy.sparse.issparse(arg1):
# Convert scipy.sparse to cupyx.scipy.sparse
x = arg1.asformat(self.format)
data = cupy.array(x.data)
indices = cupy.array(x.indices, dtype='i')
indptr = cupy.array(x.indptr, dtype='i')
copy = False
if shape is None:
shape = arg1.shape
elif isinstance(arg1, tuple) and len(arg1) == 2:
# Note: This implementation is not efficeint, as it first
# constructs a sparse matrix with coo format, then converts it to
# compressed format.
sp_coo = coo.coo_matrix(arg1, shape=shape, dtype=dtype, copy=copy)
sp_compressed = sp_coo.asformat(self.format)
data = sp_compressed.data
indices = sp_compressed.indices
indptr = sp_compressed.indptr
elif isinstance(arg1, tuple) and len(arg1) == 3:
data, indices, indptr = arg1
if not (base.isdense(data) and data.ndim == 1
and base.isdense(indices) and indices.ndim == 1
and base.isdense(indptr) and indptr.ndim == 1):
raise ValueError('data, indices, and indptr should be 1-D')
if len(data) != len(indices):
raise ValueError('indices and data should have the same size')
elif base.isdense(arg1):
if arg1.ndim > 2:
raise TypeError('expected dimension <= 2 array or matrix')
elif arg1.ndim == 1:
arg1 = arg1[None]
elif arg1.ndim == 0:
arg1 = arg1[None, None]
data, indices, indptr = self._convert_dense(arg1)
copy = False
if shape is None:
shape = arg1.shape
else:
raise ValueError('Unsupported initializer format')
if dtype is None:
dtype = data.dtype
else:
dtype = numpy.dtype(dtype)
if dtype.char not in '?fdFD':
raise ValueError(
'Only bool, float32, float64, complex64 and complex128 '
'are supported')
data = data.astype(dtype, copy=copy)
sparse_data._data_matrix.__init__(self, data)
self.indices = indices.astype('i', copy=copy)
self.indptr = indptr.astype('i', copy=copy)
if shape is None:
shape = self._swap(len(indptr) - 1, int(indices.max()) + 1)
major, minor = self._swap(*shape)
if len(indptr) != major + 1:
raise ValueError('index pointer size (%d) should be (%d)' %
(len(indptr), major + 1))
self._descr = cusparse.MatDescriptor.create()
self._shape = shape