def mean(self, axis=None, dtype=None, out=None):
"""Compute the arithmetic mean along the specified axis.
Args:
axis (int or ``None``): Axis along which the sum is computed.
If it is ``None``, it computes the average of all the elements.
Select from ``{None, 0, 1, -2, -1}``.
Returns:
cupy.ndarray: Summed array.
.. seealso::
:meth:`scipy.sparse.spmatrix.mean`
"""
sputils.validateaxis(axis)
nRow, nCol = self.shape
data = self.data.copy()
if axis is None:
n = nRow * nCol
elif axis in (0, -2):
n = nRow
else:
n = nCol
return self._with_data(data / n).sum(axis, dtype, out)
def _min_or_max(self, axis, out, min_or_max, explicit):
if out is not None:
raise ValueError(("Sparse matrices do not support "
"an 'out' parameter."))
sputils.validateaxis(axis)
if axis is None:
if 0 in self.shape:
raise ValueError("zero-size array to reduction operation")
zero = cupy.zeros((), dtype=self.dtype)
if self.nnz == 0:
return zero
self.sum_duplicates()
m = min_or_max(self.data)
if explicit:
return m
if self.nnz != internal.prod(self.shape):
if min_or_max is cupy.min:
m = cupy.minimum(zero, m)
elif min_or_max is cupy.max:
m = cupy.maximum(zero, m)
else:
assert False
return m
if axis < 0:
axis += 2
return self._min_or_max_axis(axis, min_or_max, explicit)
def sum(self, axis=None, dtype=None, out=None):
"""Sums the matrix elements over a given axis.
Args:
axis (int or ``None``): Axis along which the sum is comuted.
If it is ``None``, it computes the sum of all the elements.
Select from ``{None, 0, 1, -2, -1}``.
dtype: The type of returned matrix. If it is not specified, type
of the array is used.
out (cupy.ndarray): Output matrix.
Returns:
cupy.ndarray: Summed array.
.. seealso::
:meth:`scipy.sparse.spmatrix.sum`
"""
sputils.validateaxis(axis)
# This implementation uses multiplication, though it is not efficient
# for some matrix types. These should override this function.
m, n = self.shape
if axis is None:
return self.dot(cupy.ones(n, dtype=self.dtype)).sum(
dtype=dtype, out=out)
if axis < 0:
axis += 2
if axis == 0:
ret = self.T.dot(cupy.ones(m, dtype=self.dtype)).reshape(1, n)
else: # axis == 1
ret = self.dot(cupy.ones(n, dtype=self.dtype)).reshape(m, 1)
if out is not None:
if out.shape != ret.shape:
raise ValueError('dimensions do not match')
out[:] = ret
return out
elif dtype is not None:
return ret.astype(dtype, copy=False)
else:
return ret
def _arg_min_or_max(self, axis, out, op, compare):
if out is not None:
raise ValueError("Sparse matrices do not support "
"an 'out' parameter.")
sputils.validateaxis(axis)
if axis is None:
if 0 in self.shape:
raise ValueError("Can't apply the operation to "
"an empty matrix.")
if self.nnz == 0:
return 0
else:
zero = self.dtype.type(0)
mat = self.tocoo()
mat.sum_duplicates()
am = op(mat.data)
m = mat.data[am]
if compare(m, zero):
return mat.row[am] * mat.shape[1] + mat.col[am]
else:
size = cupy.prod(mat.shape)
if size == mat.nnz:
return am
else:
ind = mat.row * mat.shape[1] + mat.col
zero_ind = _find_missing_index(ind, size)
if m == zero:
return min(zero_ind, am)
else:
return zero_ind
if axis < 0:
axis += 2
return self._arg_min_or_max_axis(axis, op)
def mean(self, axis=None, dtype=None, out=None):
"""
Compute the arithmetic mean along the specified axis.
Returns the average of the matrix elements. The average is taken
over all elements in the matrix by default, otherwise over the
specified axis. `float64` intermediate and return values are used
for integer inputs.
Args:
axis {-2, -1, 0, 1, None}: optional
Axis along which the mean is computed. The default is to
compute the mean of all elements in the matrix
(i.e., `axis` = `None`).
dtype (dtype): optional
Type to use in computing the mean. For integer inputs, the
default is `float64`; for floating point inputs, it is the same
as the input dtype.
out (cupy.ndarray): optional
Alternative output matrix in which to place the result. It must
have the same shape as the expected output, but the type of the
output values will be cast if necessary.
Returns:
m (cupy.ndarray) : Output array of means
.. seealso::
:meth:`scipy.sparse.spmatrix.mean`
"""
def _is_integral(dtype):
return (cupy.issubdtype(dtype, cupy.integer) or
cupy.issubdtype(dtype, cupy.bool_))
sputils.validateaxis(axis)
res_dtype = self.dtype.type
integral = _is_integral(self.dtype)
# output dtype
if dtype is None:
if integral:
res_dtype = cupy.float64
else:
res_dtype = cupy.dtype(dtype).type
# intermediate dtype for summation
inter_dtype = cupy.float64 if integral else res_dtype
inter_self = self.astype(inter_dtype)
if axis is None:
return (inter_self / cupy.array(
self.shape[0] * self.shape[1]))\
.sum(dtype=res_dtype, out=out)
if axis < 0:
axis += 2
# axis = 0 or 1 now
if axis == 0:
return (inter_self * (1.0 / self.shape[0])).sum(
axis=0, dtype=res_dtype, out=out)
else:
return (inter_self * (1.0 / self.shape[1])).sum(
axis=1, dtype=res_dtype, out=out)
