Die Matrixinversion ist eine mathematische Operation, bei der es, wie der Title schon sagt, darum geht, die „inverse Matrix“ für eine gegebene Matrix zu ermitteln. Die inverse Matrix ist die Matrix, die bei Multiplikation mit der Originalmatrix die Identitätsmatrix ergibt. Es ist wichtig zu beachten, dass nicht alle Matrizen eine Umkehrung haben; Matrizen, die eine Umkehrung haben, werden „invertierbare Matrizen“ oder „nicht singuläre Matrizen“ genannt.
Der Prozess der Matrixinversion ist rechenintensiv, vor allem aufgrund der Artwork der beteiligten mathematischen Operationen. Der Customary-Matrixinversionsalgorithmus hat eine zeitliche Komplexität von O(n³), was bedeutet, dass die Rechenzeit mit der Größe der Matrix schnell zunimmt (kubisch mit der Anzahl der Komponenten). Darüber hinaus erfordert die Matrixinversion die Durchführung zahlreicher Gleitkommaberechnungen, die bei unsachgemäßer Handhabung zu Rundungsfehlern und numerischer Instabilität führen können.
Trotz dieser Herausforderungen spielt die Matrixinversion in vielen Bereichen der Wissenschaft und Technik eine grundlegende Rolle. In der Tierzucht wird die Matrixinversion beispielsweise bei Schätzanalysen von Parametern in gemischten linearen Modellen verwendet, die die Grundlage für die genetische Selektion bilden. Diese Modelle werden verwendet, um die genetische Leistung von Tieren vorherzusagen, mit dem Ziel, die besten Individuen für die Fortpflanzung zu identifizieren.
Außerhalb der Tierzucht ist die Matrixinversion auch in vielen anderen Bereichen von entscheidender Bedeutung, darunter unter anderem: Lösen linearer Gleichungssysteme, Netzwerkanalyse, Ökonometrie, Systemoptimierung, maschinelles Lernen und Signalverarbeitung. Zusammenfassend lässt sich sagen, dass die Matrixinversion trotz ihres Rechenaufwands ein wesentliches Werkzeug im Arsenal moderner Wissenschaft und Technik ist.
Die Matrixinversion ist zwar rechenintensiv, kann jedoch durch eine Reihe alternativer Techniken optimiert werden, die den Rechenaufwand insbesondere bei großen Matrizen erheblich reduzieren. Methoden wie die LU-Zerlegung, die Cholesky-Zerlegung, die QR-Zerlegung, die Gauß-Jordan-Methode und die Determinantenmethode bieten effizientere Strategien für die Matrixinversion. Bei diesen Techniken wird die ursprüngliche Matrix in einfachere Formen zerlegt oder eine Reihe elementarer Operationen angewendet, um die Matrix auf eine leichter manipulierbare Kind zu reduzieren, wodurch die Berechnung der Umkehrung effizienter und weniger anfällig für Rundungsfehler wird. In vielen Situationen ist es effizienter, die entsprechenden linearen Gleichungssysteme zu lösen, anstatt eine Matrix direkt umzukehren. Dies kann mithilfe von Techniken wie der LU-Zerlegung oder der Gauß-Jordan-Methode erfolgen. Solche alternativen Ansätze spielen eine entscheidende Rolle bei der praktischen Umsetzung von Matrixberechnungen und treiben Fortschritte in einem breiten Spektrum wissenschaftlicher und technologischer Bereiche voran.
Erstellen wir zunächst eine Funktion zum Generieren invertierbarer Matrizen und definieren wir unseren Rechenaufwand unter Berücksichtigung der Zeit und des Spitzenspeicherverbrauchs, die zum Invertieren der Matrix erforderlich sind.
Wir können diese Matrizen ganz einfach erstellen. Lassen Sie uns eine Zufallsmatrix (A) generieren und diese mit ihrer Transponierten (AT) multiplizieren. Dadurch wird eine positiv particular symmetrische Matrix erzeugt.
import numpy as np
# Generate a random matrix
A = np.random.rand(1000,1000)# Create a optimistic particular symmetric matrix
Matrix = np.dot(A, A.T)print(Matrix)
Additionally haben wir:
[[346.5979911 265.38275116 256.26402957 ... 245.80078252 267.13380138
256.84901862]
[265.38275116 360.55081534 263.97122819 ... 261.22509249 277.64630251
271.39898847]
[256.26402957 263.97122819 336.49803262 ... 244.84151498 262.82901393
252.33494426]
...
[245.80078252 261.22509249 244.84151498 ... 324.99095213 251.39806184
252.99577792]
[267.13380138 277.64630251 262.82901393 ... 251.39806184 353.25654529
260.15549937]
[256.84901862 271.39898847 252.33494426 ... 252.99577792 260.15549937
335.02079887]]
Und wie messen wir die Zeit und den Spitzenspeicherverbrauch? Wir werden die Zeit nutzen und Memory_profiler Module, und wir berechnen die Kosten für die Invertierung einer Matrix mit einer Größe von 1000 Zeilen und Spalten direkt mithilfe von np.linalg.inv() Funktion von Numpy um unsere Methodik zu testen. Hier ist ein Beispiel in Python:
Zuerst importieren wir die relevanten Bibliotheken:
import numpy as np
import time
from memory_profiler import memory_usage
Und wir erstellen eine Funktion zum Invertieren der Matrix basierend auf Numpy, zusammen mit den Paketen, die wir zur Messung des Rechenaufwands verwenden werden:
def invert_matrix(Matrix):
# Measure or use preliminary reminiscence
mem_before = memory_usage(-1, interval=0.1, timeout=1)[0]# Measure the beginning time
start_time = time.time()
strive:
A_inv = np.linalg.inv(A)
besides np.linalg.LinAlgError:
print("Matriz é singular e não pode ser invertida.")
return None
# Measure the tip time
end_time = time.time()
# Measure final reminiscence utilization
mem_after = memory_usage(-1, interval=0.1, timeout=1)[0]
# Calculate and print runtime
print("Execution time: ", end_time - start_time, "seconds")
# Calculate and print reminiscence utilization
print("Reminiscence utilization: ", mem_after - mem_before, "MiB")
return A_inv
# Instance of use
A_inv = invert_matrix(A)
if A_inv is just not None:
print(A_inv)
Hier verwenden wir die np.linalg.inv Funktion für unseren Take a look at (die keine direkte Matrixinversion ist).
Ergebnis:
Execution time: 0.22894835472106934 segundos
Reminiscence utilization: 8.4453125 MiB
[[-0.22440157 -0.11734082 0.2651931 ... 0.05743279 -0.02913667
0.03216334]
[ 0.32815818 0.19427521 -0.22804691 ... -0.12614379 -0.05541012
-0.02195372]
[ 0.02748701 0.008787 0.09213851 ... -0.04512599 -0.00655794
-0.04441288]
...
[ 0.32767353 0.11321216 -0.23788117 ... 0.01607856 -0.07020798
0.0057955 ]
[ 0.12156325 0.06088216 -0.07164596 ... 0.01916564 -0.01757929
0.00743931]
[ 0.76110064 0.33654407 -0.64459896 ... -0.33153027 -0.08015695
-0.00390345]]
Hier haben wir eine Zeit von 0,22 Sekunden und einen Rechenaufwand von 8,44 MiB, um unsere 1000 x 1000-Matrix umzukehren, die korrekt funktioniert. Kommen wir nun zu den zu testenden Methoden.
1. LU-Zerlegungsmethode
Die LU-Zerlegung zerlegt die Matrix in zwei Matrizen – eine untere Dreiecksmatrix und eine obere Dreiecksmatrix. Diese Methode ist beim Umgang mit großen Matrizen nützlich, da sie die Berechnung wesentlich effizienter macht.
Wir können diese Methode durch verwenden scipy Funktion der Bibliothek scipy.linalg.lu_factor().
import numpy as np
import scipy.linalg
import time
from memory_profiler import memory_usagedef invert_matrix_lu(Matrix):
n = Matrix.form[0]
# Measure preliminary reminiscence utilization
mem_before = memory_usage(-1, interval=0.1, timeout=1)[0]
# Measure the beginning time
start_time = time.time()
strive:
lu, piv = scipy.linalg.lu_factor(A)
A_inv = np.zeros((n, n))
for i in vary(n):
e = np.zeros((n,))
e[i] = 1.
A_inv[:, i] = scipy.linalg.lu_solve((lu, piv), e)
besides np.linalg.LinAlgError:
print("Matriz é singular e não pode ser invertida.")
return None
# Measure the tip time
end_time = time.time()
# Measure closing reminiscence utilization
mem_after = memory_usage(-1, interval=0.1, timeout=1)[0]
# Calculate and print runtime
print("Execution time: ", end_time - start_time, "seconds")
# Calculate and print reminiscence utilization
print("Reminiscence utilization: ", mem_after - mem_before, "MiB")
return A_inv
# Instance of use
A_inv = invert_matrix_lu(A)
if A_inv is just not None:
print(A_inv)
In diesem Code ist die invert_matrix_lu() Die Funktion führt eine LU-Zerlegung der Matrix A unter Verwendung von durch scipy.linalg.lu_factor() Funktion. Anschließend werden mehrere Gleichungssysteme der Kind gelöst Ax = ewobei e ein Einheitsvektor ist, um die Spalten der inversen Matrix zu berechnen.
2. Cholesky-Zerlegungsmethode
Diese Methode wird hauptsächlich auf symmetrische und positiv particular Matrizen angewendet. Die Matrix wird in eine untere Dreiecksmatrix und die Transponierte dieser unteren Dreiecksmatrix zerlegt.
Auch hier verwenden wir die scipy Bibliothek, aber die Funktion ist scipy.linalg.cholesky().
import numpy as np
import scipy.linalg
import time
from memory_profiler import memory_usagedef invert_matrix_cholesky(Matrix):
n = Matrix.form[0]
# Measure preliminary reminiscence utilization
mem_before = memory_usage(-1, interval=0.1, timeout=1)[0]
# Measure the beginning time
start_time = time.time()
strive:
# Doing the Cholesky Decomposition
c = scipy.linalg.cholesky(Matrix)
# Inverting the c matrix
c_inv = scipy.linalg.inv(c)
# Getting the inverse of A
A_inv = np.dot(c_inv.T, c_inv)
besides np.linalg.LinAlgError:
print("Matrix is singular and can't be inverted, or is just not appropriate for Cholesky decomposition.")
return None
# Measure the tip time
end_time = time.time()
# Measure closing reminiscence utilization
mem_after = memory_usage(-1, interval=0.1, timeout=1)[0]
# Calculate and print runtime
print("Execution time: ", end_time - start_time, "seconds")
# Calculate and print reminiscence utilization
print("Reminiscence utilization: ", mem_after - mem_before, "MiB")
return A_inv
# Instance of use
A_inv = invert_matrix_cholesky(Matrix)
if A_inv is just not None:
print(A_inv)
Der Prozess der Matrixinversion mit diesem Code läuft wie folgt ab:
c = scipy.linalg.cholesky(Matrix): Diese Zeile führt die Cholesky-Zerlegung der Eingabematrix durch. Die Cholesky-Zerlegung zerlegt die Eingabematrix in eine untere Dreiecksmatrix C und deren Transponierte.c_inv = scipy.linalg.inv(c): Diese Zeile berechnet die Umkehrung der unteren Dreiecksmatrix „c“, die aus der Cholesky-Zerlegung resultierte. Das Invertieren einer Dreiecksmatrix ist rechnerisch effizienter als das Invertieren einer beliebigen Matrix.A_inv = np.dot(c_inv.T, c_inv): Diese Zeile berechnet die Umkehrung der ursprünglichen Matrix Matrix. Eine Eigenschaft der Cholesky-Zerlegung besteht darin, dass die Umkehrung der ursprünglichen Matrix gleich dem Produkt der Umkehrung der oberen Dreiecksmatrix (die die Transponierte von ist) ist c_inv) und die Umkehrung der unteren Dreiecksmatrix c_inv. Der np.dot() Die Funktion wird verwendet, um die Matrixmultiplikation durchzuführen.
3. QR-Zerlegungsmethode
Durch die QR-Zerlegung wird die Matrix in eine orthogonale Matrix (q) und eine obere Dreiecksmatrix (r) zerlegt. Diese Methode eignet sich unter anderem zum Lösen linearer Gleichungssysteme und zum Berechnen von Eigenwerten und Eigenvektoren.
Hier verwenden wir die scipy.linalg.qr() Funktion aus derselben Bibliothek.
import numpy as np
import scipy.linalg
import time
from memory_profiler import memory_usagedef invert_matrix_qr(Matrix):
n = Matrix.form[0]
# Measure preliminary reminiscence utilization
mem_before = memory_usage(-1, interval=0.1, timeout=1)[0]
# Measure the beginning time
start_time = time.time()
strive:
# Doing the QR decomposition
q, r = scipy.linalg.qr(Matrix)
# Inverting the r matrix
r_inv = scipy.linalg.inv(r)
# Getting the inverse of Matrix
A_inv = np.dot(r_inv, q.T)
besides np.linalg.LinAlgError:
print("Matrix is singular and can't be inverted, or is just not appropriate for QR decomposition.")
return None
# Measure the tip time
end_time = time.time()
# Measure final reminiscence utilization
mem_after = memory_usage(-1, interval=0.1, timeout=1)[0]
# Calculate and print runtime
print("Execution time: ", end_time - start_time, "seconds")
# Calculate and print reminiscence utilization
print("Reminiscence utilization: ", mem_after - mem_before, "MiB")
return A_inv
# Instance of use
A_inv = invert_matrix_qr(Matrix)
if A_inv is just not None:
print(A_inv)
Der Prozess der Matrixinversion mit diesem Code läuft wie folgt ab:
q, r = scipy.linalg.qr(A): Diese Zeile führt die QR-Zerlegung für die Eingabematrix A durch scipy.linalg.qr() Die Funktion gibt zwei Matrizen zurück: „q“, eine orthogonale Matrix, und „r“, eine obere Dreiecksmatrix.r_inv = scipy.linalg.inv(r): Diese Zeile berechnet die Umkehrung der Matrix R, die sich aus der QR-Zerlegung ergibt. Da es sich bei „r“ um eine obere Dreiecksmatrix handelt, ist diese Operation effizienter als das Invertieren einer beliebigen Matrix.A_inv = np.dot(r_inv, q.T): Diese Zeile berechnet die Umkehrung der ursprünglichen Matrix A. Gemäß den Eigenschaften der QR-Zerlegung ist die Umkehrung von A das Produkt der Umkehrung von „r“ und der Transponierten von „q“. Der np.dot() Die Funktion wird verwendet, um die Matrixmultiplikation durchzuführen.
4. Gauß-Jordan-Methode
Die Gauß-Jordan-Methode wird verwendet, um die Umkehrung einer Matrix zu finden, indem die gegebene Matrix auf eine Identitätsform reduziert wird. Obwohl sie möglicherweise weniger effizient ist als einige der anderen genannten Methoden, handelt es sich um eine direkte Methode zum Ermitteln der Umkehrung einer Matrix.
Bei dieser Methode können die Berechnungen komplexer werden und wir verwenden nur die Numpy Bibliothek:
import numpy as np
import time
from memory_profiler import memory_usagedef invert_matrix_gauss_jordan(Matrix):
n = Matrix.form[0]
# Measure preliminary reminiscence utilization
mem_before = memory_usage(-1, interval=0.1, timeout=1)[0]
# Measure the beginning time
start_time = time.time()
strive:
# Creates an augmented matrix [Matrix|I]
augmented_matrix = np.hstack((Matrix, np.id(n)))
for i in vary(n):
# Normalizing line i
augmented_matrix[i] = augmented_matrix[i] / augmented_matrix[i, i]
for j in vary(n):
if i != j:
# Subtracting from row j the row i occasions the aspect j, i of the matrix
augmented_matrix[j] -= augmented_matrix[i] * augmented_matrix[j, i]
# Separating the inverse matrix from the augmented matrix
A_inv = augmented_matrix[:, n:]
besides np.linalg.LinAlgError:
print("Matrix is singular and can't be inverted.")
return None
# Measure the tip time
end_time = time.time()
# Measure closing reminiscence utilization
mem_after = memory_usage(-1, interval=0.1, timeout=1)[0]
# Calculate and print runtime
print("Execution time: ", end_time - start_time, "seconds")
# Calculate and print reminiscence utilization
print("Reminiscence utilization: ", mem_after - mem_before, "MiB")
return A_inv
# Instance of use
A_inv = invert_matrix_gauss_jordan(Matrix)
if A_inv is just not None:
print(A_inv)
Hier ist eine kurze Erklärung des Codes:
augmented_matrix = np.hstack((A, np.id(n))): Diese Zeile erstellt eine erweiterte Matrix, indem sie die ursprüngliche Matrix A und eine Identitätsmatrix I der Größe nxn nebeneinander (horizontal) kombiniert. Die erweiterte Matrix stellt das Gleichungssystem AX = I dar, wobei X die inverse Matrix ist, die wir finden möchten.- Die erste Schleife
for i in vary(n):iteriert durch jede Zeile der Matrix.
augmented_matrix[i] = augmented_matrix[i] / augmented_matrix[i, i]: Diese Zeile normalisiert die i-te Zeile der Matrix, indem sie die gesamte Zeile durch das Diagonalelement dividiert. Dadurch wird sichergestellt, dass das Diagonalelement 1 wird.- O zweite Schleife
for j in vary(n):durchläuft jede Zeile erneut.
if i != j: Wenn Zeile j sich von Zeile i unterscheidet (wir möchten die Zeile, die wir gerade normalisiert haben, nicht ändern)… augmented_matrix[j] -= augmented_matrix[i] * augmented_matrix[j, i]: Wir subtrahieren von Zeile j die Zeile i multipliziert mit dem Aspect an Place (j, i). Dadurch wird sichergestellt, dass alle Elemente außerhalb der Diagonale 0 werden, was zu einer Matrix in der reduzierten Zeilenstufenform von Gauß-Jordan führt.A_inv = augmented_matrix[:, n:]Diese Linie trennt die inverse Matrix von der erweiterten Matrix. Am Ende des Gauß-Jordan-Prozesses wird die erweiterte Matrix die Kind haben [I|X], wobei I die Identitätsmatrix und X die Umkehrmatrix ist. Daher können wir die inverse Matrix erhalten, indem wir alle Spalten nach der n-ten Spalte nehmen.
Dies ist ein Algorithmus zum Finden der Umkehrung einer Matrix, der eine Reihe elementarer Operationen anwendet, um die gegebene Matrix auf eine Identitätsmatrix zu reduzieren.
5. Montante-Methode
Die Montante-Methode (auch bekannt als Bareiss-Algorithmus) ist eine Variante der Gaußschen Eliminationsmethode, die zur Lösung linearer Gleichungssysteme verwendet wird. Genau wie die Gauß-Jordan-Methode umfasst die Montante-Methode Zeilen- und Spaltenoperationen, um die Matrix in eine Kind umzuwandeln, in der die Lösung leicht identifiziert werden kann (z. B. Diagonalform oder Zeilenstufenform). Daher steigt der Rechenaufwand mit der Größe der Matrix schnell an.
Ein Vorteil der Montante-Methode gegenüber der Gauß-Jordan-Methode besteht jedoch darin, dass Divisionsoperationen vermieden werden, was dazu beitragen kann, Rundungsfehler zu reduzieren und die Methode numerisch stabiler zu machen. Aufgrund seiner kubischen Zeitkomplexität wird es jedoch in der Regel immer noch nicht für umfangreiche numerische Berechnungen verwendet.
Auch hier verwenden wir nur Numpy:
import numpy as np
import time
from memory_profiler import memory_usagedef invert_matrix_montant(Matrix):
n = Matrix.form[0]
# Measure the beginning time
mem_before = memory_usage(-1, interval=0.1, timeout=1)[0]
# Measure the beginning time
start_time = time.time()
# Creates an augmented matrix [Matrix|I]
augmented_matrix = np.hstack((Matrix, np.id(n)))
strive:
# Loop over every line
for okay in vary(n):
pivot = augmented_matrix[k, k]
augmented_matrix[k] = augmented_matrix[k] / pivot
for i in vary(n):
if i != okay:
issue = augmented_matrix[i, k]
augmented_matrix[i] -= issue * augmented_matrix[k]
# Separating the inverse matrix from the augmented matrix
A_inv = augmented_matrix[:, n:]
besides np.linalg.LinAlgError:
print("Matrix is singular and can't be inverted.")
return None
# Measure the tip time
end_time = time.time()
# Measure closing reminiscence utilization
mem_after = memory_usage(-1, interval=0.1, timeout=1)[0]
# Calculate and print runtime
print("Execution time: ", end_time - start_time, "seconds")
# Calculate and print reminiscence utilization
print("Reminiscence utilization: ", mem_after - mem_before, "MiB")
return A_inv
# Instance of use
A_inv = invert_matrix_montant(Matrix)
if A_inv is just not None:
print(A_inv)
for okay in vary(n):– Dies ist die äußere Schleife, die jede Zeile der Matrix durchläuft.pivot = augmented_matrix[k, k]– Diese Zeile wählt das Pivot-Aspect aus, das das Diagonalelement der Zeile okay ist.augmented_matrix[k] = augmented_matrix[k] / pivot— Diese Linie teilt die gesamte Zeile okay durch das Pivot-Aspect und normalisiert so das Pivot-Aspect auf 1.for i in vary(n):– Dies ist eine innere Schleife, die alle Zeilen der Matrix durchläuft.if i != okay:— Dies prüft, ob sich die aktuelle Zeile i von Zeile okay unterscheidet. Wir möchten die Zeile okay, die wir gerade normalisiert haben, nicht ändern.issue = augmented_matrix[i, k]– Diese Zeile erhält den Faktor, der zum Eliminieren des Parts in Zeile i und Spalte okay verwendet wird.augmented_matrix[i] -= issue * augmented_matrix[k]— Diese Zeile subtrahiert Zeile okay multipliziert mit dem Faktor von Zeile i. Dies führt zu einem Nullelement an Place (i, okay), da wir Aspect (i, okay) von Zeile okay subtrahieren (wobei Aspect (okay, okay) eins ist).A_inv = augmented_matrix[:, n:]— Schließlich, nachdem alle Zeilen verarbeitet wurden, ist die erweiterte Matrix eine Identitätsmatrix, die mit der Umkehrung der ursprünglichen Matrix verkettet ist. Diese Zeile trennt die inverse Matrix von der erweiterten Matrix.
Codes etabliert. Um nun eine Vorstellung vom Fortschritt zu bekommen, kehren wir Matrizen mit den Größen 2500, 5000, 7500 und 10000 Zeilen und Spalten um.
Beginnen wir mit der Rechenzeit für die 4 getesteten Methoden:
Abbildung 1 – Zeit in Sekunden für die Matrixinversion.
Tabelle 1 – Zeit in Sekunden für die Matrixinversion.
Wir können deutlich erkennen, dass die Cholesky-Methode bei der Matrixinversion am schnellsten ist, und hier sehen wir keinen kleinen Unterschied, sondern eher eine große Lücke in der Inversionsgeschwindigkeit. Unter Berücksichtigung der 10.000 x 10.000-Matrix benötigte die Cholesky-Methode weniger als 5 % der Zeit im Vergleich zur Gauß-Jordan-Methode und nur die Hälfte der Zeit im Vergleich zur zweitschnellsten Methode (QR-Zerlegung). Ist diese Methode jedoch diejenige, die am wenigsten RAM-Speicher verbraucht?
Abbildung 2 – RAM-Speicherverbrauch für die Matrixinversion.
Tabelle 2 – RAM-Speicherverbrauch für Matrixinversion.
Hier sehen wir, dass die langsamen Methoden von Gauss-Jordan und Montante im Vergleich zur QR-Zerlegungsmethode quick die Hälfte des Speichers verbrauchen und die schnelle Cholesky-Methode hinsichtlich des Speicherverbrauchs nicht beeindruckt. Wenn wir beide Rechenkostenmaße berücksichtigen, die wir zur Erstellung einer Kosten-Nutzen-Analyse verwendet haben, können wir die LU-Zerlegungsmethode und sogar die Cholesky-Methode hervorheben.
Die hier erzielten Ergebnisse können variieren, je nachdem, was Sie tun. Ich hoffe jedoch, dass dieser kleine Vergleich etwas Licht in Ihre Studien bringt und Ihnen dabei hilft, die beste Methode für Ihre Forschung zu finden. Wenn Sie beispielsweise Geschwindigkeit benötigen und über hervorragende {Hardware} verfügen, wählen Sie die Cholesky-Methode. Wenn Ihre Ausrüstung jedoch begrenzt ist und Ihnen lange Wartezeiten nichts ausmachen, können die Gauß-Jordan- und Montante-Methoden eine gute Choice sein.
Es ist wichtig zu beachten, dass diese Methoden zwar bei der Matrixinversion genau sind, bei sehr großen Matrizen jedoch möglicherweise nicht die effizientesten sind. Bei großen Datenmengen können Sie Methoden in Betracht ziehen, die im Austausch für einen geringeren Zeit- und Speicherverbrauch etwas Präzision einbüßen, wie etwa iterative oder Näherungsmethoden für die Matrixinversion.
