Classe « bsr_matrix »

Informations générales

Héritage

        builtins.object
            _minmax_mixin
    builtins.object
        IndexMixin
    builtins.object
        _minmax_mixin
builtins.object
    spmatrix
        _data_matrix
            _cs_matrix
                bsr_matrix

Définition

class bsr_matrix(_cs_matrix, _minmax_mixin):

Description _{[extrait de bsr_matrix.doc]}

Block Sparse Row matrix

    This can be instantiated in several ways:
        bsr_matrix(D, [blocksize=(R,C)])
            where D is a dense matrix or 2-D ndarray.

        bsr_matrix(S, [blocksize=(R,C)])
            with another sparse matrix S (equivalent to S.tobsr())

        bsr_matrix((M, N), [blocksize=(R,C), dtype])
            to construct an empty matrix with shape (M, N)
            dtype is optional, defaulting to dtype='d'.

        bsr_matrix((data, ij), [blocksize=(R,C), shape=(M, N)])
            where ``data`` and ``ij`` satisfy ``a[ij[0, k], ij[1, k]] = data[k]``

        bsr_matrix((data, indices, indptr), [shape=(M, N)])
            is the standard BSR representation where the block column
            indices for row i are stored in ``indices[indptr[i]:indptr[i+1]]``
            and their corresponding block 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.

    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
        Data array of the matrix
    indices
        BSR format index array
    indptr
        BSR format index pointer array
    blocksize
        Block size of the matrix
    has_sorted_indices
        Whether indices are sorted

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

    **Summary of BSR format**

    The Block Compressed Row (BSR) format is very similar to the Compressed
    Sparse Row (CSR) format. BSR is appropriate for sparse matrices with dense
    sub matrices like the last example below.  Block matrices often arise in
    vector-valued finite element discretizations. In such cases, BSR is
    considerably more efficient than CSR and CSC for many sparse arithmetic
    operations.

    **Blocksize**

    The blocksize (R,C) must evenly divide the shape of the matrix (M,N).
    That is, R and C must satisfy the relationship ``M % R = 0`` and
    ``N % C = 0``.

    If no blocksize is specified, a simple heuristic is applied to determine
    an appropriate blocksize.

    Examples
    --------
    >>> from scipy.sparse import bsr_matrix
    >>> bsr_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])
    >>> bsr_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]).repeat(4).reshape(6, 2, 2)
    >>> bsr_matrix((data,indices,indptr), shape=(6, 6)).toarray()
    array([[1, 1, 0, 0, 2, 2],
           [1, 1, 0, 0, 2, 2],
           [0, 0, 0, 0, 3, 3],
           [0, 0, 0, 0, 3, 3],
           [4, 4, 5, 5, 6, 6],
           [4, 4, 5, 5, 6, 6]])

Constructeur(s)

Signature du constructeur	Description
__init__(self, arg1, shape=None, dtype=None, copy=False, blocksize=None)

Liste des attributs statiques

Nom de l'attribut	Valeur
format	bsr
ndim	2

Liste des propriétés

Nom de la propriété	Description
blocksize
dtype
has_canonical_format	Determine whether the matrix has sorted indices and no duplicates _{[extrait de __doc__]}
has_sorted_indices	Determine whether the matrix has sorted indices _{[extrait de __doc__]}
nnz	Number of stored values, including explicit zeros. _{[extrait de __doc__]}
shape	Get shape of a matrix. _{[extrait de __doc__]}

Liste des opérateurs

Signature de l'opérateur	Description
__getitem__(self, key)
__setitem__(self, key, val)

Opérateurs hérités de la classe _cs_matrix

__eq__, __ge__, __gt__, __le__, __lt__, __ne__

Opérateurs hérités de la classe _data_matrix

__imul__, __itruediv__, __neg__

Opérateurs hérités de la classe spmatrix

__add__, __iadd__, __isub__, __matmul__, __mul__, __pow__, __radd__, __rmul__, __rsub__, __rtruediv__, __sub__, __truediv__

Liste des méthodes

Toutes les méthodes Méthodes d'instance Méthodes statiques

Signature de la méthode	Description
__repr__(self)
check_format(self, full_check=True)	check whether the matrix format is valid _{[extrait de check_format.__doc__]}
diagonal(self, k=0)	Returns the kth diagonal of the matrix. _{[extrait de diagonal.__doc__]}
eliminate_zeros(self)	Remove zero elements in-place. _{[extrait de eliminate_zeros.__doc__]}
getnnz(self, axis=None)	Number of stored values, including explicit zeros. _{[extrait de getnnz.__doc__]}
prune(self)	Remove empty space after all non-zero elements. _{[extrait de prune.__doc__]}
sort_indices(self)	Sort the indices of this matrix in place _{[extrait de sort_indices.__doc__]}
sum_duplicates(self)	Eliminate duplicate matrix entries by adding them together _{[extrait de sum_duplicates.__doc__]}
toarray(self, order=None, out=None)
tobsr(self, blocksize=None, copy=False)	Convert this matrix into Block Sparse Row Format. _{[extrait de tobsr.__doc__]}
tocoo(self, copy=True)	Convert this matrix to COOrdinate format. _{[extrait de tocoo.__doc__]}
tocsc(self, copy=False)	Convert this matrix to Compressed Sparse Column format. _{[extrait de tocsc.__doc__]}
tocsr(self, copy=False)	Convert this matrix to Compressed Sparse Row format. _{[extrait de tocsr.__doc__]}
transpose(self, axes=None, copy=False)

Méthodes héritées de la classe _cs_matrix

__init_subclass__, __subclasshook__, maximum, minimum, multiply, resize, sorted_indices, sum

Méthodes héritées de la classe IndexMixin

getcol, getrow

Méthodes héritées de la classe _minmax_mixin

argmax, argmin, max, min

Méthodes héritées de la classe _data_matrix

__abs__, __round__, astype, conj, copy, count_nonzero, power

Méthodes héritées de la classe spmatrix

__bool__, __div__, __getattr__, __idiv__, __iter__, __len__, __nonzero__, __rdiv__, __rmatmul__, __str__, asformat, asfptype, conjugate, dot, get_shape, getformat, getH, getmaxprint, mean, nonzero, reshape, set_shape, setdiag, todense, todia, todok, tolil

Méthodes héritées de la classe object

__delattr__, __dir__, __format__, __getattribute__, __hash__, __reduce__, __reduce_ex__, __setattr__, __sizeof__

Améliorations / Corrections