scipy.linalg.

lu_factor#

scipy.linalg.lu_factor(a, overwrite_a=False, check_finite=True)[Quelle]#

Berechnet die pivotierte LU-Zerlegung einer Matrix.

Die Zerlegung ist

A = P L U

wobei P eine Permutationsmatrix, L eine untere Dreiecksmatrix mit Einheiten auf der Diagonalen und U eine obere Dreiecksmatrix ist.

Die Dokumentation wurde unter der Annahme verfasst, dass die Array-Argumente bestimmte „Kern“-Formen haben. Array-Argumente dieser Funktion können jedoch zusätzliche „Batch“-Dimensionen vorangestellt haben. In diesem Fall wird das Array als Stapel von niedrigdimensionalen Schnitten behandelt; siehe Gestapelte lineare Operationen für Details.

Parameter:

a(M, N) array_like: Zu zerlegende Matrix
overwrite_abool, optional: Ob die Daten in A überschrieben werden sollen (kann die Leistung steigern)
check_finitebool, optional: Ob überprüft werden soll, ob die Eingabematrix nur endliche Zahlen enthält. Das Deaktivieren kann zu einer Leistungssteigerung führen, kann aber zu Problemen (Abstürze, Nichtterminierung) führen, wenn die Eingaben Unendlichkeiten oder NaNs enthalten.

Rückgabe:

lu(M, N) ndarray: Matrix, die U in ihrem oberen Dreieck und L in ihrem unteren Dreieck enthält. Die Einheiten auf der Diagonalen von L werden nicht gespeichert.
piv(K,) ndarray: Pivot-Indizes, die die Permutationsmatrix P darstellen: Zeile i der Matrix wurde mit Zeile piv[i] vertauscht. Von der Form (K,), mit K = min(M, N).

Siehe auch

lu: liefert die LU-Faktorisierung in einem benutzerfreundlicheren Format
lu_solve: lösen ein Gleichungssystem unter Verwendung der LU-Faktorisierung einer Matrix

Hinweise

Dies ist ein Wrapper für die *GETRF Routinen von LAPACK. Im Gegensatz zu lu gibt es die L- und U-Faktoren in einer einzigen Array aus und gibt Pivot-Indizes anstelle einer Permutationsmatrix zurück.

Während die zugrundeliegenden *GETRF Routinen 1-basierte Pivot-Indizes zurückgeben, enthält das von lu_factor zurückgegebene piv Array 0-basierte Indizes.

Beispiele

>>> import numpy as np
>>> from scipy.linalg import lu_factor
>>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
>>> lu, piv = lu_factor(A)
>>> piv
array([2, 2, 3, 3], dtype=int32)

Konvertieren des LAPACK-Pivot-Arrays in NumPy-Indizes und Testen der Permutation

>>> def pivot_to_permutation(piv):
...     perm = np.arange(len(piv))
...     for i in range(len(piv)):
...         perm[i], perm[piv[i]] = perm[piv[i]], perm[i]
...     return perm
...
>>> p_inv = pivot_to_permutation(piv)
>>> p_inv
array([2, 0, 3, 1])
>>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
>>> np.allclose(A[p_inv] - L @ U, np.zeros((4, 4)))
True

Die Matrix P in P L U wird durch die inverse Permutation definiert und kann mit argsort wiederhergestellt werden

>>> p = np.argsort(p_inv)
>>> p
array([1, 3, 0, 2])
>>> np.allclose(A - L[p] @ U, np.zeros((4, 4)))
True

oder alternativ

>>> P = np.eye(4)[p]
>>> np.allclose(A - P @ L @ U, np.zeros((4, 4)))
True