Attributes

dtype : dtype

Data type of the matrix

shape : 2-tuple

Shape of the matrix

ndim : int

Number of dimensions (this is always 2)

nnz :

Number of stored values, including explicit zeros

data :

CSR format data array of the matrix

indices :

CSR format index array of the matrix

indptr :

CSR format index pointer array of the matrix

has_sorted_indices :

Whether indices are sorted

This can be instantiated in several ways:

csr_matrix(D)

with a dense matrix or rank-2 ndarray D

csr_matrix(S)

with another sparse matrix S (equivalent to S.tocsr())

csr_matrix((M, N), [dtype])

to construct an empty matrix with shape (M, N) dtype is optional, defaulting to dtype='d'.

csr_matrix((data, (row_ind, col_ind)), [shape=(M, N)])

where data , row_ind and col_ind satisfy the relationship a[row_ind[k], col_ind[k]] = data[k] .

csr_matrix((data, indices, indptr), [shape=(M, N)])

is the standard CSR representation where the column indices for row i are stored in indices[indptr[i]:indptr[i+1]] and their corresponding values are stored in data[indptr[i]:indptr[i+1]] . If the shape parameter is not supplied, the matrix dimensions are inferred from the index arrays.

Notes

Sparse matrices can be used in arithmetic operations: they support addition, subtraction, multiplication, division, and matrix power.

Advantages of the CSR format

• efficient arithmetic operations CSR + CSR, CSR * CSR, etc.

• efficient row slicing

• fast matrix vector products

Disadvantages of the CSR format

• slow column slicing operations (consider CSC)

• changes to the sparsity structure are expensive (consider LIL or DOK)

Compressed Sparse Row matrix

Examples

>>> import numpy as np
... from scipy.sparse import csr_matrix
... csr_matrix((3, 4), dtype=np.int8).toarray()
array([[0, 0, 0, 0],
       [0, 0, 0, 0],
       [0, 0, 0, 0]], dtype=int8)

>>> row = np.array([0, 0, 1, 2, 2, 2])
... col = np.array([0, 2, 2, 0, 1, 2])
... data = np.array([1, 2, 3, 4, 5, 6])
... csr_matrix((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 2],
       [0, 0, 3],
       [4, 5, 6]])

>>> indptr = np.array([0, 2, 3, 6])
... indices = np.array([0, 2, 2, 0, 1, 2])
... data = np.array([1, 2, 3, 4, 5, 6])
... csr_matrix((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 2],
       [0, 0, 3],
       [4, 5, 6]])

Duplicate entries are summed together:

>>> row = np.array([0, 1, 2, 0])
... col = np.array([0, 1, 1, 0])
... data = np.array([1, 2, 4, 8])
... csr_matrix((data, (row, col)), shape=(3, 3)).toarray()
array([[9, 0, 0],
       [0, 2, 0],
       [0, 4, 0]])

As an example of how to construct a CSR matrix incrementally, the following snippet builds a term-document matrix from texts:

>>> docs = [["hello", "world", "hello"], ["goodbye", "cruel", "world"]]
... indptr = [0]
... indices = []
... data = []
... vocabulary = {}
... for d in docs:
...     for term in d:
...         index = vocabulary.setdefault(term, len(vocabulary))
...         indices.append(index)
...         data.append(1)
...     indptr.append(len(indices))
...

>>> csr_matrix((data, indices, indptr), dtype=int).toarray()
array([[2, 1, 0, 0],
       [0, 1, 1, 1]])

See :

Back References

The following pages refer to to this document either explicitly or contain code examples using this.

scipy

43 Elements

scipy.sparse._coo.isspmatrix_coo

scipy.sparse.csgraph._traversal.depth_first_order

scipy.sparse.csgraph._flow.maximum_flow

scipy.sparse.csgraph._tools.reconstruct_path

scipy.sparse._base.spmatrix.nonzero

scipy.sparse.csgraph._traversal.breadth_first_order

scipy.sparse._compressed._cs_matrix.diagonal

scipy.sparse._extract.triu

scipy.sparse.csgraph._shortest_path.bellman_ford

scipy.sparse._base.spmatrix.diagonal

scipy.sparse._dia.isspmatrix_dia

scipy.sparse._coo.coo_matrix.tocsr

scipy.sparse.csgraph._traversal.connected_components

scipy.sparse._base.spmatrix.dot

scipy.sparse._csr.csr_matrix

scipy.sparse._csr.isspmatrix_csr

scipy.sparse.csgraph._reordering.reverse_cuthill_mckee

scipy.sparse._csc.csc_matrix.nonzero

scipy.sparse.csgraph._tools.csgraph_to_masked

scipy.sparse._dia.dia_matrix.diagonal

scipy.sparse._extract.find

scipy.sparse._dok.isspmatrix_dok

scipy.sparse.csgraph._reordering.structural_rank

scipy.sparse.csgraph._shortest_path.floyd_warshall

scipy.sparse.csgraph._shortest_path.shortest_path

scipy.sparse.linalg._eigen._svds.svds

scipy.sparse._bsr.bsr_matrix.diagonal

scipy.sparse.csgraph._matching.min_weight_full_bipartite_matching

scipy.sparse.linalg._norm.norm

scipy.sparse.csgraph._matching.maximum_bipartite_matching

scipy.sparse.csgraph._tools.csgraph_to_dense

scipy.sparse.csgraph._shortest_path.johnson

scipy.sparse._coo.coo_matrix.diagonal

scipy.sparse._lil.isspmatrix_lil

scipy.sparse._csc.isspmatrix_csc

scipy.sparse.linalg._isolve.minres.minres

scipy.sparse.linalg._dsolve.linsolve.spsolve_triangular

scipy.sparse._extract.tril

scipy.sparse._construct.kron

scipy.sparse._bsr.isspmatrix_bsr

scipy.sparse._base.isspmatrix

scipy.sparse.csgraph._tools.construct_dist_matrix

scipy.sparse.csgraph._shortest_path.dijkstra

networkx

networkx.utils.rcm.cuthill_mckee_ordering

networkx.convert_matrix.from_scipy_sparse_matrix

networkx.linalg.bethehessianmatrix.bethe_hessian_matrix

networkx.utils.rcm.reverse_cuthill_mckee_ordering

networkx.convert_matrix.to_scipy_sparse_matrix

Local connectivity graph

Hover to see nodes names; edges to Self not shown, Caped at 50 nodes.

Using a canvas is more power efficient and can get hundred of nodes ; but does not allow hyperlinks; , arrows or text (beyond on hover)

SVG is more flexible but power hungry; and does not scale well to 50 + nodes.

All aboves nodes referred to, (or are referred from) current nodes; Edges from Self to other have been omitted (or all nodes would be connected to the central node "self" which is not useful). Nodes are colored by the library they belong to, and scaled with the number of references pointing them

---

GitHub : /scipy/sparse/_csr.py#17
type: <class 'type'>
Commit: