|
"""Base class for sparse matrice with a .data attribute
subclasses must provide a _with_data() method that creates a new matrix with the same sparsity pattern as self but with a different data array
"""
# TODO implement all relevant operations # use .data.__methods__() instead of /=, *=, etc. spmatrix.__init__(self)
return self.data.dtype
self.data.dtype = newtype
if hasattr(self, 'sum_duplicates'): self.sum_duplicates() return self.data
return self._with_data(abs(self._deduped_data()))
return self._with_data(self.data.real)
return self._with_data(self.data.imag)
if self.dtype.kind == 'b': raise NotImplementedError('negating a sparse boolean ' 'matrix is not supported') return self._with_data(-self.data)
if isscalarlike(other): self.data *= other return self else: return NotImplemented
if isscalarlike(other): recip = 1.0 / other self.data *= recip return self else: return NotImplemented
dtype = np.dtype(dtype) if self.dtype != dtype: return self._with_data( self._deduped_data().astype(dtype, casting=casting, copy=copy), copy=copy) elif copy: return self.copy() else: return self
if np.issubdtype(self.dtype, np.complexfloating): return self._with_data(self.data.conj(), copy=copy) elif copy: return self.copy() else: return self
return self._with_data(self.data.copy(), copy=True)
return np.count_nonzero(self._deduped_data())
""" This function performs element-wise power.
Parameters ---------- n : n is a scalar
dtype : If dtype is not specified, the current dtype will be preserved. """ if not isscalarlike(n): raise NotImplementedError("input is not scalar")
data = self._deduped_data() if dtype is not None: data = data.astype(dtype) return self._with_data(data ** n)
########################### # Multiplication handlers # ###########################
return self._with_data(self.data * other)
# Add the numpy unary ufuncs for which func(0) = 0 to _data_matrix.
result = op(self._deduped_data()) return self._with_data(result, copy=True)
"See numpy.%s for more information." % (name, name))
for k, a in enumerate(ind): if k != a: return k
k += 1 if k < n: return k else: return -1
"""Mixin for min and max methods.
These are not implemented for dia_matrix, hence the separate class. """
N = self.shape[axis] if N == 0: raise ValueError("zero-size array to reduction operation") M = self.shape[1 - axis]
mat = self.tocsc() if axis == 0 else self.tocsr() mat.sum_duplicates()
major_index, value = mat._minor_reduce(min_or_max) not_full = np.diff(mat.indptr)[major_index] < N value[not_full] = min_or_max(value[not_full], 0)
mask = value != 0 major_index = np.compress(mask, major_index) value = np.compress(mask, value)
from . import coo_matrix if axis == 0: return coo_matrix((value, (np.zeros(len(value)), major_index)), dtype=self.dtype, shape=(1, M)) else: return coo_matrix((value, (major_index, np.zeros(len(value)))), dtype=self.dtype, shape=(M, 1))
if out is not None: raise ValueError(("Sparse matrices do not support " "an 'out' parameter."))
validateaxis(axis)
if axis is None: if 0 in self.shape: raise ValueError("zero-size array to reduction operation")
zero = self.dtype.type(0) if self.nnz == 0: return zero m = min_or_max.reduce(self._deduped_data().ravel()) if self.nnz != np.product(self.shape): m = min_or_max(zero, m) return m
if axis < 0: axis += 2
if (axis == 0) or (axis == 1): return self._min_or_max_axis(axis, min_or_max) else: raise ValueError("axis out of range")
if self.shape[axis] == 0: raise ValueError("Can't apply the operation along a zero-sized " "dimension.")
if axis < 0: axis += 2
zero = self.dtype.type(0)
mat = self.tocsc() if axis == 0 else self.tocsr() mat.sum_duplicates()
ret_size, line_size = mat._swap(mat.shape) ret = np.zeros(ret_size, dtype=int)
nz_lines, = np.nonzero(np.diff(mat.indptr)) for i in nz_lines: p, q = mat.indptr[i:i + 2] data = mat.data[p:q] indices = mat.indices[p:q] am = op(data) m = data[am] if compare(m, zero) or q - p == line_size: ret[i] = indices[am] else: zero_ind = _find_missing_index(indices, line_size) if m == zero: ret[i] = min(am, zero_ind) else: ret[i] = zero_ind
if axis == 1: ret = ret.reshape(-1, 1)
return matrix(ret)
if out is not None: raise ValueError("Sparse matrices do not support " "an 'out' parameter.")
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 = np.product(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
return self._arg_min_or_max_axis(axis, op, compare)
""" Return the maximum of the matrix or maximum along an axis. This takes all elements into account, not just the non-zero ones.
Parameters ---------- axis : {-2, -1, 0, 1, None} optional Axis along which the sum is computed. The default is to compute the maximum over all the matrix elements, returning a scalar (i.e. `axis` = `None`).
out : None, optional This argument is in the signature *solely* for NumPy compatibility reasons. Do not pass in anything except for the default value, as this argument is not used.
Returns ------- amax : coo_matrix or scalar Maximum of `a`. If `axis` is None, the result is a scalar value. If `axis` is given, the result is a sparse.coo_matrix of dimension ``a.ndim - 1``.
See Also -------- min : The minimum value of a sparse matrix along a given axis. np.matrix.max : NumPy's implementation of 'max' for matrices
""" return self._min_or_max(axis, out, np.maximum)
""" Return the minimum of the matrix or maximum along an axis. This takes all elements into account, not just the non-zero ones.
Parameters ---------- axis : {-2, -1, 0, 1, None} optional Axis along which the sum is computed. The default is to compute the minimum over all the matrix elements, returning a scalar (i.e. `axis` = `None`).
out : None, optional This argument is in the signature *solely* for NumPy compatibility reasons. Do not pass in anything except for the default value, as this argument is not used.
Returns ------- amin : coo_matrix or scalar Minimum of `a`. If `axis` is None, the result is a scalar value. If `axis` is given, the result is a sparse.coo_matrix of dimension ``a.ndim - 1``.
See Also -------- max : The maximum value of a sparse matrix along a given axis. np.matrix.min : NumPy's implementation of 'min' for matrices
""" return self._min_or_max(axis, out, np.minimum)
"""Return indices of maximum elements along an axis.
Implicit zero elements are also taken into account. If there are several maximum values, the index of the first occurrence is returned.
Parameters ---------- axis : {-2, -1, 0, 1, None}, optional Axis along which the argmax is computed. If None (default), index of the maximum element in the flatten data is returned. out : None, optional This argument is in the signature *solely* for NumPy compatibility reasons. Do not pass in anything except for the default value, as this argument is not used.
Returns ------- ind : np.matrix or int Indices of maximum elements. If matrix, its size along `axis` is 1. """ return self._arg_min_or_max(axis, out, np.argmax, np.greater)
"""Return indices of minimum elements along an axis.
Implicit zero elements are also taken into account. If there are several minimum values, the index of the first occurrence is returned.
Parameters ---------- axis : {-2, -1, 0, 1, None}, optional Axis along which the argmin is computed. If None (default), index of the minimum element in the flatten data is returned. out : None, optional This argument is in the signature *solely* for NumPy compatibility reasons. Do not pass in anything except for the default value, as this argument is not used.
Returns ------- ind : np.matrix or int Indices of minimum elements. If matrix, its size along `axis` is 1. """ return self._arg_min_or_max(axis, out, np.argmin, np.less) |