# scipy.sparse.csc_array#

class scipy.sparse.csc_array(arg1, shape=None, dtype=None, copy=False)[source]#

Compressed Sparse Column matrix

This can be instantiated in several ways:

csc_array(D)

with a dense matrix or rank-2 ndarray D

csc_array(S)

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

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

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

csc_array((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]`.

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

is the standard CSC representation where the row indices for column 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.

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

• efficient column slicing

• fast matrix vector products (CSR, BSR may be faster)

• slow row slicing operations (consider CSR)

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

Canonical format
• Within each column, indices are sorted by row.

• There are no duplicate entries.

Examples

```>>> import numpy as np
>>> from scipy.sparse import csc_array
>>> csc_array((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, 2, 2, 0, 1, 2])
>>> col = np.array([0, 0, 1, 2, 2, 2])
>>> data = np.array([1, 2, 3, 4, 5, 6])
>>> csc_array((data, (row, col)), shape=(3, 3)).toarray()
array([[1, 0, 4],
[0, 0, 5],
[2, 3, 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])
>>> csc_array((data, indices, indptr), shape=(3, 3)).toarray()
array([[1, 0, 4],
[0, 0, 5],
[2, 3, 6]])
```
Attributes:
dtypedtype

Data type of the matrix

`shape`2-tuple

The shape of the array.

ndimint

Number of dimensions (this is always 2)

`nnz`

Number of stored values, including explicit zeros.

data

Data array of the matrix

indices

CSC format index array

indptr

CSC format index pointer array

`has_sorted_indices`

Determine whether the matrix has sorted indices

Methods

 Element-wise arcsin. Element-wise arcsinh. Element-wise arctan. Element-wise arctanh. `argmax`([axis, out]) Return indices of maximum elements along an axis. `argmin`([axis, out]) Return indices of minimum elements along an axis. `asformat`(format[, copy]) Return this array in the passed format. Upcast array to a floating point format (if necessary) `astype`(dtype[, casting, copy]) Cast the array elements to a specified type. Element-wise ceil. `check_format`([full_check]) check whether the matrix format is valid `conj`([copy]) Element-wise complex conjugation. `conjugate`([copy]) Element-wise complex conjugation. Returns a copy of this array. Number of non-zero entries, equivalent to Element-wise deg2rad. `diagonal`([k]) Returns the kth diagonal of the array. `dot`(other) Ordinary dot product Remove zero entries from the matrix Element-wise expm1. Element-wise floor. Return the Hermitian transpose of this array. Get shape of a sparse array. Returns a copy of column j of the array, as an (m x 1) sparse array (column vector). Matrix storage format. Maximum number of elements to display when printed. `getnnz`([axis]) Number of stored values, including explicit zeros. Returns a copy of row i of the array, as a (1 x n) sparse array (row vector). Element-wise log1p. `max`([axis, out]) Return the maximum of the matrix or maximum along an axis. `maximum`(other) Element-wise maximum between this and another array. `mean`([axis, dtype, out]) Compute the arithmetic mean along the specified axis. `min`([axis, out]) Return the minimum of the matrix or maximum along an axis. `minimum`(other) Element-wise minimum between this and another array. `multiply`(other) Point-wise multiplication by another matrix, vector, or scalar. `nanmax`([axis, out]) Return the maximum of the matrix or maximum along an axis, ignoring any NaNs. `nanmin`([axis, out]) Return the minimum of the matrix or minimum along an axis, ignoring any NaNs. nonzero indices `power`(n[, dtype]) This function performs element-wise power. Remove empty space after all non-zero elements. Element-wise rad2deg. `reshape`(self, shape[, order, copy]) Gives a new shape to a sparse array without changing its data. `resize`(*shape) Resize the array in-place to dimensions given by `shape` Element-wise rint. `set_shape`(shape) `setdiag`(values[, k]) Set diagonal or off-diagonal elements of the array. Element-wise sign. Element-wise sin. Element-wise sinh. Sort the indices of this matrix in place Return a copy of this matrix with sorted indices Element-wise sqrt. `sum`([axis, dtype, out]) Sum the array elements over a given axis. Eliminate duplicate matrix entries by adding them together Element-wise tan. Element-wise tanh. `toarray`([order, out]) Return a dense ndarray representation of this sparse array. `tobsr`([blocksize, copy]) Convert this array to Block Sparse Row format. `tocoo`([copy]) Convert this array to COOrdinate format. `tocsc`([copy]) Convert this array to Compressed Sparse Column format. `tocsr`([copy]) Convert this array to Compressed Sparse Row format. `todense`([order, out]) Return a dense matrix representation of this sparse array. `todia`([copy]) Convert this array to sparse DIAgonal format. `todok`([copy]) Convert this array to Dictionary Of Keys format. `tolil`([copy]) Convert this array to List of Lists format. `trace`([offset]) Returns the sum along diagonals of the sparse array. `transpose`([axes, copy]) Reverses the dimensions of the sparse array. Element-wise trunc.
 __getitem__ __mul__