Construct Sparse Arrays¶
From coordinates and data¶
You can construct
COO arrays from coordinates and value data.
coords parameter contains the indices where the data is nonzero,
data parameter contains the data corresponding to those indices.
For example, the following code will generate a \(5 \times 5\) diagonal
import sparse coords = [[0, 1, 2, 3, 4], [0, 1, 2, 3, 4]] data = [10, 20, 30, 40, 50] s = sparse.COO(coords, data) >>> s.todense() array([[10, 0, 0, 0, 0], [ 0, 20, 0, 0, 0], [ 0, 0, 30, 0, 0], [ 0, 0, 0, 40, 0], [ 0, 0, 0, 0, 50]])
coords should be a
(ndim, nnz) shaped
array. Each row of
coords contains one dimension of the
desired sparse array, and each column contains the index
corresponding to that nonzero element.
the nonzero elements of the array corresponding to the indices
coords. Its shape should be
You can, and should, pass in
numpy.ndarray objects for
In this case, the shape of the resulting array was determined from
the maximum index in each dimension. If the array extends beyond
the maximum index in
coords, you should supply a shape
explicitly. For example, if we did the following without the
shape keyword argument, it would result in a
\(4 \times 5\) matrix, but maybe we wanted one that was actually
\(5 \times 5\).
coords = [[0, 3, 2, 1], [4, 1, 2, 0]] data = [1, 4, 2, 1] s = COO(coords, data, shape=(5, 5))
s = COO.from_scipy_sparse(x)
From Numpy arrays¶
s = COO.from_numpy(x)
s = sparse.random((10, 10), density=0.1)
It’s possible to build
COO arrays from
DOK arrays, if it is not
easy to construct the
data in a simple way.
arrays provide a simple builder interface to build
COO arrays, but at
this time, they can do little else.
You can get started by defining the shape (and optionally, datatype) of the
DOK array. If you do not specify a dtype, it is inferred from the value
dictionary or is set to
dtype('float64') if that is not present.
s = DOK((6, 5, 2)) s2 = DOK((2, 3, 4), dtype=np.uint8)
After this, you can build the array by assigning arrays or scalars to elements or slices of the original array. Broadcasting rules are followed.
s[1:3, 3:1:-1] = [[6, 5]]
s3 = COO(s)
In addition, it is possible to access single elements of the
using normal Numpy indexing.
s[1, 2, 1] # 5 s[5, 1, 1] # 0
COO.todense: Converts to a