scipy.sparse.

bsr_array#

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

Block Sparse Row-Format sparse array.

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

wobei D eine 2D-ndarray ist.

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

mit einem anderen Sparse-Array oder einer anderen Sparse-Matrix S (entspricht S.tobsr())

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

zum Erstellen eines leeren Sparse-Arrays mit der Form (M, N). dtype ist optional und hat standardmäßig den Wert 'd'.

bsr_array((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_array((data, indices, indptr), [shape=(M, N)])

ist die Standard-BSR-Repräsentation, bei der die Block-Spaltenindizes 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 Array-Dimensionen aus den Index-Arrays abgeleitet.

Attribute:
dtypedtype

Datentyp des Arrays

shape2-tuple

Form des Arrays

ndimint

Anzahl der Dimensionen (dies ist immer 2)

nnz

Anzahl der gespeicherten Werte, einschließlich expliziter Nullen.

size

Anzahl der gespeicherten Werte.

data

Datenarray im BSR-Format des Arrays

indices

Indexarray im BSR-Format des Arrays

indptr

Indexzeigerarray im BSR-Format des Arrays

blocksize

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__()

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.

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.

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.

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 dieses Sparse Arrays 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__

__mul__

Hinweise

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

Zusammenfassung des BSR-Formats

Das Block Sparse Row (BSR)-Format ist dem Compressed Sparse Row (CSR)-Format sehr ähnlich. BSR eignet sich für dünnbesetzte Matrizen mit dichten Untermatrizen, wie im letzten Beispiel unten gezeigt. Solche dünnbesetzten Blockmatrizen entstehen häufig bei Vektor-wertigen Finite-Elemente-Diskretisierungen. In solchen Fällen ist BSR für viele dünnbesetzte arithmetische Operationen deutlich effizienter als CSR und CSC.

Blockgröße

Die Blockgröße (R, C) muss die Form des Sparse-Arrays (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 Sparse-Arrays unterstützen kein Slicing.

Beispiele

>>> import numpy as np
>>> from scipy.sparse import bsr_array
>>> bsr_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, 0, 1, 2, 2, 2])
>>> col = np.array([0, 2, 2, 0, 1, 2])
>>> data = np.array([1, 2, 3 ,4, 5, 6])
>>> bsr_array((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_array((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