COO

class sparse.COO(coords, data=None, shape=None, has_duplicates=True, sorted=False, cache=False, fill_value=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.
  • shape (tuple[int] (COO.ndim,)) – The shape of the array.
  • has_duplicates (bool, optional) – A value indicating whether the supplied value for coords has duplicates. Note that setting this to False when coords does have duplicates may result in undefined behaviour. See COO.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. See COO.sort_indices.
  • 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,)
shape

The dimensions of this array.

Type:tuple[int] (ndim,)

See also

DOK
A mostly write-only sparse array.
as_coo
Convert any given format to COO.

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  # doctest: +NORMALIZE_WHITESPACE
array([1, 1, 1, 5, 1], dtype=uint8)
>>> s.coords  # doctest: +NORMALIZE_WHITESPACE
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()  # doctest: +NORMALIZE_WHITESPACE
array([[2, 0, 0, 0],
       [0, 2, 0, 0],
       [0, 0, 2, 5],
       [0, 0, 5, 2]], dtype=uint8)
>>> (s * s2).todense()  # doctest: +NORMALIZE_WHITESPACE
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()  # doctest: +NORMALIZE_WHITESPACE
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()   # doctest: +NORMALIZE_WHITESPACE
array([ 1,  1, 31,  6], dtype=uint64)

You can use Numpy ufunc operations on COO arrays as well.

>>> np.sum(s, axis=1).todense()  # doctest: +NORMALIZE_WHITESPACE
array([1, 1, 6, 1], dtype=uint64)
>>> np.round(np.sqrt(s, dtype=np.float64), decimals=1).todense()   # doctest: +SKIP
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()  # doctest: +NORMALIZE_WHITESPACE
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()  # doctest: +NORMALIZE_WHITESPACE
array([[4, 0],
       [0, 2]])

You can convert DOK arrays to COO 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()  # doctest: +NORMALIZE_WHITESPACE
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]])

Note

COO objects also support operators and indexing

Attributes

COO.T Returns a new array which has the order of the axes reversed.
COO.dtype The datatype of this array.
COO.nbytes The number of bytes taken up by this object.
COO.ndim The number of dimensions of this array.
COO.nnz The number of nonzero elements in this array.
COO.size The number of all elements (including zeros) in this array.
COO.density The ratio of nonzero to all elements in this array.
COO.imag The imaginary part of the array.
COO.real The real part of the array.

Constructing COO objects

COO.from_iter(x[, shape, fill_value]) Converts an iterable in certain formats to a COO array.
COO.from_numpy(x[, fill_value]) Convert the given numpy.ndarray to a COO object.
COO.from_scipy_sparse(x) Construct a COO array from a scipy.sparse.spmatrix

Element-wise operations

COO.astype(dtype) 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.

Reductions

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.mean([axis, keepdims, dtype, out]) Compute the mean 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.

Converting to other formats

COO.asformat(format) Convert this sparse array to a given format.
COO.todense() Convert this COO array to a dense numpy.ndarray.
COO.maybe_densify([max_size, min_density]) Converts this COO array to a numpy.ndarray if not too costly.
COO.to_scipy_sparse() Converts this COO object into a scipy.sparse.coo_matrix.
COO.tocsc() Converts this array to a scipy.sparse.csc_matrix.
COO.tocsr() Converts this array to a scipy.sparse.csr_matrix.

Other operations

COO.copy([deep]) Return a copy of the array.
COO.dot(other) Performs the equivalent of x.dot(y) for COO.
COO.reshape(shape[, order]) Returns a new COO array that is a reshaped version of this array.
COO.transpose([axes]) Returns a new array which has the order of the axes switched.
COO.nonzero() Get the indices where this array is nonzero.

Utility functions

COO.broadcast_to(shape) Performs the equivalent of numpy.broadcast_to for COO.
COO.enable_caching() Enable caching of reshape, transpose, and tocsr/csc operations
COO.linear_loc() The nonzero coordinates of a flattened version of this array.