COO
- class sparse.COO(coords, data=None, shape=None, has_duplicates=True, sorted=False, prune=False, cache=False, fill_value=None, idx_dtype=None)[source]
A sparse multidimensional array.
This is stored in COO format. It depends on NumPy and Scipy.sparse for computation, but supports arrays of arbitrary dimension.
- Parameters:
coords (numpy.ndarray (COO.ndim, COO.nnz)) – An array holding the index locations of every value Should have shape (number of dimensions, number of non-zeros).
data (numpy.ndarray (COO.nnz,)) – An array of Values. A scalar can also be supplied if the data is the same across all coordinates. If not given, defers to
as_coo
.has_duplicates (bool, optional) – A value indicating whether the supplied value for
coords
has duplicates. Note that setting this to False whencoords
does have duplicates may result in undefined behaviour. SeeCOO.sum_duplicates
sorted (bool, optional) – A value indicating whether the values in coords are sorted. Note that setting this to True when
coords
isn’t sorted may result in undefined behaviour. SeeCOO.sort_indices
.prune (bool, optional) – A flag indicating whether or not we should prune any fill-values present in
data
.cache (bool, optional) – Whether to enable cacheing for various operations. See
COO.enable_caching
fill_value (scalar, optional) – The fill value for this array.
- coords
An array holding the coordinates of every nonzero element.
- Type:
numpy.ndarray (ndim, nnz)
- data
An array holding the values corresponding to
COO.coords
.- Type:
numpy.ndarray (nnz,)
Examples
You can create
COO
objects from Numpy arrays.>>> x = np.eye(4, dtype=np.uint8) >>> x[2, 3] = 5 >>> s = COO.from_numpy(x) >>> s <COO: shape=(4, 4), dtype=uint8, nnz=5, fill_value=0> >>> s.data array([1, 1, 1, 5, 1], dtype=uint8) >>> s.coords array([[0, 1, 2, 2, 3], [0, 1, 2, 3, 3]])
COO
objects support basic arithmetic and binary operations.>>> x2 = np.eye(4, dtype=np.uint8) >>> x2[3, 2] = 5 >>> s2 = COO.from_numpy(x2) >>> (s + s2).todense() array([[2, 0, 0, 0], [0, 2, 0, 0], [0, 0, 2, 5], [0, 0, 5, 2]], dtype=uint8) >>> (s * s2).todense() array([[1, 0, 0, 0], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]], dtype=uint8)
Binary operations support broadcasting.
>>> x3 = np.zeros((4, 1), dtype=np.uint8) >>> x3[2, 0] = 1 >>> s3 = COO.from_numpy(x3) >>> (s * s3).todense() array([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 1, 5], [0, 0, 0, 0]], dtype=uint8)
COO
objects also support dot products and reductions.>>> s.dot(s.T).sum(axis=0).todense() array([ 1, 1, 31, 6], dtype=uint64)
You can use Numpy
ufunc
operations onCOO
arrays as well.>>> np.sum(s, axis=1).todense() array([1, 1, 6, 1], dtype=uint64) >>> np.round(np.sqrt(s, dtype=np.float64), decimals=1).todense() array([[ 1. , 0. , 0. , 0. ], [ 0. , 1. , 0. , 0. ], [ 0. , 0. , 1. , 2.2], [ 0. , 0. , 0. , 1. ]])
Operations that will result in a dense array will usually result in a different fill value, such as the following.
>>> np.exp(s) <COO: shape=(4, 4), dtype=float16, nnz=5, fill_value=1.0>
You can also create
COO
arrays from coordinates and data.>>> coords = [[0, 0, 0, 1, 1], [0, 1, 2, 0, 3], [0, 3, 2, 0, 1]] >>> data = [1, 2, 3, 4, 5] >>> s4 = COO(coords, data, shape=(3, 4, 5)) >>> s4 <COO: shape=(3, 4, 5), dtype=int64, nnz=5, fill_value=0>
If the data is same across all coordinates, you can also specify a scalar.
>>> coords = [[0, 0, 0, 1, 1], [0, 1, 2, 0, 3], [0, 3, 2, 0, 1]] >>> data = 1 >>> s5 = COO(coords, data, shape=(3, 4, 5)) >>> s5 <COO: shape=(3, 4, 5), dtype=int64, nnz=5, fill_value=0>
Following scipy.sparse conventions you can also pass these as a tuple with rows and columns
>>> rows = [0, 1, 2, 3, 4] >>> cols = [0, 0, 0, 1, 1] >>> data = [10, 20, 30, 40, 50] >>> z = COO((data, (rows, cols))) >>> z.todense() array([[10, 0], [20, 0], [30, 0], [ 0, 40], [ 0, 50]])
You can also pass a dictionary or iterable of index/value pairs. Repeated indices imply summation:
>>> d = {(0, 0, 0): 1, (1, 2, 3): 2, (1, 1, 0): 3} >>> COO(d) <COO: shape=(2, 3, 4), dtype=int64, nnz=3, fill_value=0> >>> L = [((0, 0), 1), ((1, 1), 2), ((0, 0), 3)] >>> COO(L).todense() array([[4, 0], [0, 2]])
You can convert
DOK
arrays toCOO
arrays.>>> from sparse import DOK >>> s6 = DOK((5, 5), dtype=np.int64) >>> s6[1:3, 1:3] = [[4, 5], [6, 7]] >>> s6 <DOK: shape=(5, 5), dtype=int64, nnz=4, fill_value=0> >>> s7 = s6.asformat("coo") >>> s7 <COO: shape=(5, 5), dtype=int64, nnz=4, fill_value=0> >>> s7.todense() array([[0, 0, 0, 0, 0], [0, 4, 5, 0, 0], [0, 6, 7, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]])
Attributes
Returns a new array which has the order of the axes reversed.
The datatype of this array.
The number of bytes taken up by this object.
The number of dimensions of this array.
The number of nonzero elements in this array.
The number of all elements (including zeros) in this array.
The ratio of nonzero to all elements in this array.
The imaginary part of the array.
The real part of the array.
COO.from_iter
(x[, shape, fill_value, dtype])Converts an iterable in certain formats to a
COO
array.COO.from_numpy
(x[, fill_value, idx_dtype])Convert the given
numpy.ndarray
to aCOO
object.Construct a
COO
array from ascipy.sparse.spmatrix
COO.astype
(dtype[, casting, copy])Copy of the array, cast to a specified type.
COO.conj
()Return the complex conjugate, element-wise.
COO.clip
([min, max, out])Clip (limit) the values in the array.
COO.round
([decimals, out])Evenly round to the given number of decimals.
COO.reduce
(method[, axis, keepdims])Performs a reduction operation on this array.
COO.sum
([axis, keepdims, dtype, out])Performs a sum operation along the given axes.
COO.prod
([axis, keepdims, dtype, out])Performs a product operation along the given axes.
COO.min
([axis, keepdims, out])Minimize along the given axes.
COO.max
([axis, keepdims, out])Maximize along the given axes.
COO.any
([axis, keepdims, out])See if any values along array are
True
.COO.all
([axis, keepdims, out])See if all values in an array are
True
.COO.mean
([axis, keepdims, dtype, out])Compute the mean along the given axes.
COO.std
([axis, dtype, out, ddof, keepdims])Compute the standard deviation along the given axes.
COO.var
([axis, dtype, out, ddof, keepdims])Compute the variance along the given axes.
COO.asformat
(format, **kwargs)Convert this sparse array to a given format.
Convert this
COO
array to a densenumpy.ndarray
.COO.maybe_densify
([max_size, min_density])Converts this
COO
array to anumpy.ndarray
if not too costly.Converts this
COO
object into ascipy.sparse.coo_matrix
.Converts this array to a
scipy.sparse.csc_matrix
.Converts this array to a
scipy.sparse.csr_matrix
.COO.copy
([deep])Return a copy of the array.
COO.dot
(other)Performs the equivalent of
x.dot(y)
forCOO
.COO.flatten
([order])Returns a new
COO
array that is a flattened version of this array.COO.reshape
(shape[, order])Returns a new
COO
array that is a reshaped version of this array.COO.resize
(*args[, refcheck, coords_dtype])This method changes the shape and size of an array in-place.
COO.transpose
([axes])Returns a new array which has the order of the axes switched.
COO.swapaxes
(axis1, axis2)Returns array that has axes axis1 and axis2 swapped.
Get the indices where this array is nonzero.
Utility functions
COO.broadcast_to
(shape)Performs the equivalent of
numpy.broadcast_to
forCOO
.Enable caching of reshape, transpose, and tocsr/csc operations
The nonzero coordinates of a flattened version of this array.