scipy.sparse.

bsr_matrix#

class scipy.sparse.bsr_matrix(arg1, shape=None, dtype=None, copy=False, blocksize=None, *, maxprint=None)[Quelle]#

Block Sparse Row (BSR) Format Sparse Matrix.

Dies kann auf verschiedene Arten instanziiert werden
bsr_matrix(D, [blocksize=(R,C)])

wobei D ein 2D-ndarray ist.

bsr_matrix(S, [blocksize=(R,C)])

mit einer anderen dünnbesetzten (sparse) Array oder Matrix S (äquivalent zu S.tobsr())

bsr_matrix((M, N), [blocksize=(R,C), dtype])

zum Erstellen einer leeren dünnbesetzten Matrix mit der Form (M, N). dtype ist optional und hat standardmäßig den Wert 'd'.

bsr_matrix((data, ij), [blocksize=(R,C), shape=(M, N)])

wobei data und ij die Bedingung a[ij[0, k], ij[1, k]] = data[k] erfüllen.

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

ist die Standard-BSR-Darstellung, bei der die Blockspaltenindizes für Zeile i in indices[indptr[i]:indptr[i+1]] gespeichert sind und ihre entsprechenden Blockwerte in data[ indptr[i]: indptr[i+1] ] gespeichert sind. Wenn der Parameter shape nicht angegeben wird, werden die Matrixdimensionen aus den Index-Arrays abgeleitet.

Attribute:
dtypedtype

Datentyp der Matrix

shape2-Tupel

Form der Matrix

ndimint

Anzahl der Dimensionen (dies ist immer 2)

nnz

Anzahl der gespeicherten Werte, einschließlich expliziter Nullen.

size

Anzahl der gespeicherten Werte.

data

BSR-Format-Datenarray der Matrix

indices

BSR-Format-Indexarray der Matrix

indptr

BSR-Format-Indexzeigerarray der Matrix

Blockgröße

Blockgröße der Matrix.

has_sorted_indicesbool

Ob die Indizes sortiert sind

has_canonical_formatbool

Ob das Array/die Matrix sortierte Indizes und keine Duplikate hat

T

Transponierte.

Methoden

__len__()

__mul__(other)

arcsin()

Elementweise Arcussinus.

arcsinh()

Elementweise Arcusshinus.

arctan()

Elementweise Arctangens.

arctanh()

Elementweise Arcustangens.

argmax([axis, out, explicit])

Gibt die Indizes der maximalen Elemente entlang einer Achse zurück.

argmin([axis, out, explicit])

Gibt die Indizes der minimalen Elemente entlang einer Achse zurück.

asformat(format[, copy])

Gibt dieses Array/diese Matrix im übergebenen Format zurück.

asfptype()

Matrix in Fließkommaformat hochstapeln (falls erforderlich)

astype(dtype[, casting, copy])

Gibt die Elemente des Arrays/der Matrix in einem angegebenen Typ aus.

ceil()

Elementweise Aufrundung.

check_format([full_check])

Prüft, ob das Array/die Matrix das BSR-Format einhält.

conj([copy])

Elementweise komplexe Konjugation.

conjugate([copy])

Elementweise komplexe Konjugation.

copy()

Gibt eine Kopie dieses Arrays/dieser Matrix zurück.

count_nonzero([axis])

Anzahl der Nicht-Null-Einträge, äquivalent zu

deg2rad()

Elementweise Umrechnung von Grad in Radiant.

diagonal([k])

Gibt die k-te Diagonale des Arrays/der Matrix zurück.

dot(other)

Gewöhnliches Skalarprodukt

eliminate_zeros()

Entfernt Nullelemente direkt.

expm1()

Elementweise expm1.

floor()

Elementweise Abrundung.

getH()

Gibt die hermitesche Transponierte dieser Matrix zurück.

get_shape()

Ruft die Form der Matrix ab

getcol(j)

Gibt eine Kopie der Spalte j der Matrix als (m x 1) Sparse-Matrix (Spaltenvektor) zurück.

getformat()

Matrixspeicherformat

getmaxprint()

Maximale Anzahl von Elementen, die beim Drucken angezeigt werden.

getnnz([axis])

Anzahl der gespeicherten Werte, einschließlich expliziter Nullen.

getrow(i)

Gibt eine Kopie der Zeile i der Matrix als (1 x n) Sparse-Matrix (Zeilenvektor) zurück.

log1p()

Elementweise log1p.

max([axis, out, explicit])

Gibt das Maximum des Arrays/der Matrix oder das Maximum entlang einer Achse zurück.

maximum(other)

Elementweises Maximum zwischen diesem und einem anderen Array/einer anderen Matrix.

mean([axis, dtype, out])

Berechnet das arithmetische Mittel entlang der angegebenen Achse.

min([axis, out, explicit])

Gibt das Minimum des Arrays/der Matrix oder das Maximum entlang einer Achse zurück.

minimum(other)

Elementweises Minimum zwischen diesem und einem anderen Array/einer anderen Matrix.

multiply(other)

Elementweise Multiplikation mit einem anderen Array/einer anderen Matrix.

nanmax([axis, out, explicit])

Gibt das Maximum zurück und ignoriert alle NaNs entlang einer Achse.

nanmin([axis, out, explicit])

Gibt das Minimum zurück und ignoriert alle NaNs entlang einer Achse.

nonzero()

Nicht-Null-Indizes des Arrays/der Matrix.

power(n[, dtype])

Diese Funktion führt elementweise Potenzierung durch.

prune()

Entfernt leeren Speicherplatz nach allen Nicht-Null-Elementen.

rad2deg()

Elementweise Umrechnung von Radiant in Grad.

reshape(self, shape[, order, copy])

Gibt einem Sparse Array/einer Sparse Matrix eine neue Form, ohne dessen/deren Daten zu ändern.

resize(*shape)

Ändert die Größe des Arrays/der Matrix direkt auf die durch shape gegebenen Dimensionen.

rint()

Elementweise Rundung zur nächsten ganzen Zahl.

set_shape(shape)

Setzt die Form der Matrix inplace

setdiag(values[, k])

Setzt diagonale oder nicht-diagonale Elemente des Arrays/der Matrix.

sign()

Elementweises Vorzeichen.

sin()

Elementweise Sinus.

sinh()

Elementweise Sinus hyperbolicus.

sort_indices()

Sortiert die Indizes dieses Arrays/dieser Matrix *direkt*.

sorted_indices()

Gibt eine Kopie dieses Arrays/dieser Matrix mit sortierten Indizes zurück.

sqrt()

Elementweise Quadratwurzel.

sum([axis, dtype, out])

Summiert die Elemente des Arrays/der Matrix über eine gegebene Achse.

sum_duplicates()

Duplizierte Array-/Matrixeinträge eliminieren, indem sie addiert werden.

tan()

Elementweise Tangens.

tanh()

Elementweise Tangens hyperbolicus.

toarray([order, out])

Gibt eine dichte ndarray-Darstellung dieses Sparse Arrays/dieser Sparse Matrix zurück.

tobsr([blocksize, copy])

Dieses Array/diese Matrix in das Block Sparse Row-Format konvertieren.

tocoo([copy])

Konvertiert dieses Array/diese Matrix in das COOrdinate (COO)-Format.

tocsc([copy])

Konvertiert dieses Array/diese Matrix in das Compressed Sparse Column (CSC)-Format.

tocsr([copy])

Konvertiert dieses Array/diese Matrix in das Compressed Sparse Row (CSR)-Format.

todense([order, out])

Gibt eine dichte Darstellung dieser Sparse-Matrix zurück.

todia([copy])

Konvertiert dieses Array/diese Matrix in das sparse DIAgonal-Format.

todok([copy])

Konvertiert dieses Array/diese Matrix in das Dictionary Of Keys (DOK)-Format.

tolil([copy])

Konvertiert dieses Array/diese Matrix in das List of Lists (LIL)-Format.

trace([offset])

Gibt die Summe entlang der Diagonalen des Sparse Arrays/der Sparse Matrix zurück.

transpose([axes, copy])

Kehrt die Dimensionen des Sparse Arrays/der Sparse Matrix um.

trunc()

Elementweise Trunkierung.

__getitem__

Hinweise

Sparse-Matrizen können in arithmetischen Operationen verwendet werden: sie unterstützen Addition, Subtraktion, Multiplikation, Division und Matrixpotenz.

Zusammenfassung des BSR-Formats

Das Block Sparse Row (BSR) Format ähnelt stark dem Compressed Sparse Row (CSR) Format. BSR eignet sich für dünnbesetzte Matrizen mit dichten Untermatrizen, wie im letzten Beispiel unten gezeigt. Solche dünnbesetzten Blockmatrizen treten häufig bei diskretisierten Finite-Element-Methoden mit Vektorwerten auf. In solchen Fällen ist BSR für viele dünnbesetzte arithmetische Operationen erheblich effizienter als CSR und CSC.

Blockgröße

Die Blockgröße (R, C) muss die Form der dünnbesetzten Matrix (M, N) gleichmäßig teilen. Das heißt, R und C müssen die Beziehung M % R = 0 und N % C = 0 erfüllen.

Wenn keine Blockgröße angegeben wird, wird eine einfache Heuristik angewendet, um eine geeignete Blockgröße zu bestimmen.

Kanonisches Format

Im kanonischen Format gibt es keine doppelten Blöcke und die Indizes sind zeilenweise sortiert.

Einschränkungen

Block Sparse Row Format dünnbesetzte Matrizen unterstützen keine Slicing-Operationen.

Beispiele

>>> import numpy as np
>>> 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]])
Auf dieser Seite