peacock-data-public-datasets-idc-cronscript
/
venv
/lib
/python3.10
/site-packages
/scipy
/sparse
/_data.py
| """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 | |
| """ | |
| import numpy as np | |
| from ._base import _spbase, _ufuncs_with_fixed_point_at_zero | |
| from ._sputils import isscalarlike, validateaxis | |
| __all__ = [] | |
| # TODO implement all relevant operations | |
| # use .data.__methods__() instead of /=, *=, etc. | |
| class _data_matrix(_spbase): | |
| def __init__(self): | |
| _spbase.__init__(self) | |
| def dtype(self): | |
| return self.data.dtype | |
| def dtype(self, newtype): | |
| self.data.dtype = newtype | |
| def _deduped_data(self): | |
| if hasattr(self, 'sum_duplicates'): | |
| self.sum_duplicates() | |
| return self.data | |
| def __abs__(self): | |
| return self._with_data(abs(self._deduped_data())) | |
| def __round__(self, ndigits=0): | |
| return self._with_data(np.around(self._deduped_data(), decimals=ndigits)) | |
| def _real(self): | |
| return self._with_data(self.data.real) | |
| def _imag(self): | |
| return self._with_data(self.data.imag) | |
| def __neg__(self): | |
| if self.dtype.kind == 'b': | |
| raise NotImplementedError('negating a boolean sparse array is not ' | |
| 'supported') | |
| return self._with_data(-self.data) | |
| def __imul__(self, other): # self *= other | |
| if isscalarlike(other): | |
| self.data *= other | |
| return self | |
| else: | |
| return NotImplemented | |
| def __itruediv__(self, other): # self /= other | |
| if isscalarlike(other): | |
| recip = 1.0 / other | |
| self.data *= recip | |
| return self | |
| else: | |
| return NotImplemented | |
| def astype(self, dtype, casting='unsafe', copy=True): | |
| dtype = np.dtype(dtype) | |
| if self.dtype != dtype: | |
| matrix = self._with_data( | |
| self.data.astype(dtype, casting=casting, copy=True), | |
| copy=True | |
| ) | |
| return matrix._with_data(matrix._deduped_data(), copy=False) | |
| elif copy: | |
| return self.copy() | |
| else: | |
| return self | |
| astype.__doc__ = _spbase.astype.__doc__ | |
| def conjugate(self, copy=True): | |
| if np.issubdtype(self.dtype, np.complexfloating): | |
| return self._with_data(self.data.conjugate(), copy=copy) | |
| elif copy: | |
| return self.copy() | |
| else: | |
| return self | |
| conjugate.__doc__ = _spbase.conjugate.__doc__ | |
| def copy(self): | |
| return self._with_data(self.data.copy(), copy=True) | |
| copy.__doc__ = _spbase.copy.__doc__ | |
| def count_nonzero(self): | |
| return np.count_nonzero(self._deduped_data()) | |
| count_nonzero.__doc__ = _spbase.count_nonzero.__doc__ | |
| def power(self, n, dtype=None): | |
| """ | |
| This function performs element-wise power. | |
| Parameters | |
| ---------- | |
| n : scalar | |
| n is a non-zero scalar (nonzero avoids dense ones creation) | |
| If zero power is desired, special case it to use `np.ones` | |
| dtype : If dtype is not specified, the current dtype will be preserved. | |
| Raises | |
| ------ | |
| NotImplementedError : if n is a zero scalar | |
| If zero power is desired, special case it to use | |
| `np.ones(A.shape, dtype=A.dtype)` | |
| """ | |
| if not isscalarlike(n): | |
| raise NotImplementedError("input is not scalar") | |
| if not n: | |
| raise NotImplementedError( | |
| "zero power is not supported as it would densify the matrix.\n" | |
| "Use `np.ones(A.shape, dtype=A.dtype)` for this case." | |
| ) | |
| data = self._deduped_data() | |
| if dtype is not None: | |
| data = data.astype(dtype) | |
| return self._with_data(data ** n) | |
| ########################### | |
| # Multiplication handlers # | |
| ########################### | |
| def _mul_scalar(self, other): | |
| return self._with_data(self.data * other) | |
| # Add the numpy unary ufuncs for which func(0) = 0 to _data_matrix. | |
| for npfunc in _ufuncs_with_fixed_point_at_zero: | |
| name = npfunc.__name__ | |
| def _create_method(op): | |
| def method(self): | |
| result = op(self._deduped_data()) | |
| return self._with_data(result, copy=True) | |
| method.__doc__ = (f"Element-wise {name}.\n\n" | |
| f"See `numpy.{name}` for more information.") | |
| method.__name__ = name | |
| return method | |
| setattr(_data_matrix, name, _create_method(npfunc)) | |
| def _find_missing_index(ind, n): | |
| for k, a in enumerate(ind): | |
| if k != a: | |
| return k | |
| k += 1 | |
| if k < n: | |
| return k | |
| else: | |
| return -1 | |
| class _minmax_mixin: | |
| """Mixin for min and max methods. | |
| These are not implemented for dia_matrix, hence the separate class. | |
| """ | |
| def _min_or_max_axis(self, axis, min_or_max): | |
| N = self.shape[axis] | |
| if N == 0: | |
| raise ValueError("zero-size array to reduction operation") | |
| M = self.shape[1 - axis] | |
| idx_dtype = self._get_index_dtype(maxval=M) | |
| 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) | |
| if axis == 0: | |
| return self._coo_container( | |
| (value, (np.zeros(len(value), dtype=idx_dtype), major_index)), | |
| dtype=self.dtype, shape=(1, M) | |
| ) | |
| else: | |
| return self._coo_container( | |
| (value, (major_index, np.zeros(len(value), dtype=idx_dtype))), | |
| dtype=self.dtype, shape=(M, 1) | |
| ) | |
| def _min_or_max(self, axis, out, min_or_max): | |
| if out is not None: | |
| raise ValueError("Sparse arrays do not support an 'out' parameter.") | |
| validateaxis(axis) | |
| if self.ndim == 1: | |
| if axis not in (None, 0, -1): | |
| raise ValueError("axis out of range") | |
| axis = None # avoid calling special axis case. no impact on 1d | |
| 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.prod(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") | |
| def _arg_min_or_max_axis(self, axis, argmin_or_argmax, compare): | |
| if self.shape[axis] == 0: | |
| raise ValueError("Cannot 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] | |
| extreme_index = argmin_or_argmax(data) | |
| extreme_value = data[extreme_index] | |
| if compare(extreme_value, zero) or q - p == line_size: | |
| ret[i] = indices[extreme_index] | |
| else: | |
| zero_ind = _find_missing_index(indices, line_size) | |
| if extreme_value == zero: | |
| ret[i] = min(extreme_index, zero_ind) | |
| else: | |
| ret[i] = zero_ind | |
| if axis == 1: | |
| ret = ret.reshape(-1, 1) | |
| return self._ascontainer(ret) | |
| def _arg_min_or_max(self, axis, out, argmin_or_argmax, compare): | |
| if out is not None: | |
| raise ValueError("Sparse types do not support an 'out' parameter.") | |
| validateaxis(axis) | |
| if self.ndim == 1: | |
| if axis not in (None, 0, -1): | |
| raise ValueError("axis out of range") | |
| axis = None # avoid calling special axis case. no impact on 1d | |
| if axis is not None: | |
| return self._arg_min_or_max_axis(axis, argmin_or_argmax, compare) | |
| if 0 in self.shape: | |
| raise ValueError("Cannot apply the operation to an empty matrix.") | |
| if self.nnz == 0: | |
| return 0 | |
| zero = self.dtype.type(0) | |
| mat = self.tocoo() | |
| # Convert to canonical form: no duplicates, sorted indices. | |
| mat.sum_duplicates() | |
| extreme_index = argmin_or_argmax(mat.data) | |
| extreme_value = mat.data[extreme_index] | |
| num_col = mat.shape[-1] | |
| # If the min value is less than zero, or max is greater than zero, | |
| # then we do not need to worry about implicit zeros. | |
| if compare(extreme_value, zero): | |
| # cast to Python int to avoid overflow and RuntimeError | |
| return int(mat.row[extreme_index]) * num_col + int(mat.col[extreme_index]) | |
| # Cheap test for the rare case where we have no implicit zeros. | |
| size = np.prod(self.shape) | |
| if size == mat.nnz: | |
| return int(mat.row[extreme_index]) * num_col + int(mat.col[extreme_index]) | |
| # At this stage, any implicit zero could be the min or max value. | |
| # After sum_duplicates(), the `row` and `col` arrays are guaranteed to | |
| # be sorted in C-order, which means the linearized indices are sorted. | |
| linear_indices = mat.row * num_col + mat.col | |
| first_implicit_zero_index = _find_missing_index(linear_indices, size) | |
| if extreme_value == zero: | |
| return min(first_implicit_zero_index, extreme_index) | |
| return first_implicit_zero_index | |
| def max(self, axis=None, out=None): | |
| """ | |
| Return the maximum of the array/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 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 array/matrix along a given axis. | |
| numpy.matrix.max : NumPy's implementation of 'max' for matrices | |
| """ | |
| return self._min_or_max(axis, out, np.maximum) | |
| def min(self, axis=None, out=None): | |
| """ | |
| Return the minimum of the array/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 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 array/matrix along a given axis. | |
| numpy.matrix.min : NumPy's implementation of 'min' for matrices | |
| """ | |
| return self._min_or_max(axis, out, np.minimum) | |
| def nanmax(self, axis=None, out=None): | |
| """ | |
| Return the maximum of the array/matrix or maximum along an axis, ignoring any | |
| NaNs. This takes all elements into account, not just the non-zero | |
| ones. | |
| .. versionadded:: 1.11.0 | |
| Parameters | |
| ---------- | |
| axis : {-2, -1, 0, 1, None} optional | |
| Axis along which the maximum is computed. The default is to | |
| compute the maximum over all 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 | |
| -------- | |
| nanmin : The minimum value of a sparse array/matrix along a given axis, | |
| ignoring NaNs. | |
| max : The maximum value of a sparse array/matrix along a given axis, | |
| propagating NaNs. | |
| numpy.nanmax : NumPy's implementation of 'nanmax'. | |
| """ | |
| return self._min_or_max(axis, out, np.fmax) | |
| def nanmin(self, axis=None, out=None): | |
| """ | |
| Return the minimum of the array/matrix or minimum along an axis, ignoring any | |
| NaNs. This takes all elements into account, not just the non-zero | |
| ones. | |
| .. versionadded:: 1.11.0 | |
| Parameters | |
| ---------- | |
| axis : {-2, -1, 0, 1, None} optional | |
| Axis along which the minimum is computed. The default is to | |
| compute the minimum over all 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 | |
| -------- | |
| nanmax : The maximum value of a sparse array/matrix along a given axis, | |
| ignoring NaNs. | |
| min : The minimum value of a sparse array/matrix along a given axis, | |
| propagating NaNs. | |
| numpy.nanmin : NumPy's implementation of 'nanmin'. | |
| """ | |
| return self._min_or_max(axis, out, np.fmin) | |
| def argmax(self, axis=None, out=None): | |
| """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 : numpy.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) | |
| def argmin(self, axis=None, out=None): | |
| """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 : numpy.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) | |