scipy.linalg.

lu#

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

Berechnet die LU-Zerlegung einer Matrix mit partieller Pivotsuche.

Die Zerlegung erfüllt

A = P @ L @ U

wobei P eine Permutationsmatrix ist, L eine untere Dreiecksmatrix mit Einheiten auf der Hauptdiagonale und U eine obere Dreiecksmatrix ist. Wenn permute_l auf True gesetzt ist, wird L bereits permutiert zurückgegeben und erfüllt somit A = L @ U.

Parameter:

a(M, N) array_like: Zu zerlegendes Array
permute_lbool, optional: Führt die Multiplikation P*L durch (Standard: nicht permutieren)
overwrite_abool, optional: Gibt an, ob Daten in a überschrieben werden sollen (kann die Leistung verbessern)
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.
p_indicesbool, optional: Wenn True, werden die Permutationsinformationen als Zeilenindizes zurückgegeben. Der Standardwert ist False aus Gründen der Abwärtskompatibilität.

Rückgabe:

(Wenn `permute_l` ``False`` ist)
p(…, M, M) ndarray: Permutations-Arrays oder -Vektoren je nach p_indices
l(…, M, K) ndarray: Untere Dreiecks- oder Trapezoidmatrix mit Einheitendiagonale. K = min(M, N)
u(…, K, N) ndarray: Obere Dreiecks- oder Trapezoidmatrix
(Wenn `permute_l` ``True`` ist)
pl(…, M, K) ndarray: Permutierte L-Matrix. K = min(M, N)
u(…, K, N) ndarray: Obere Dreiecks- oder Trapezoidmatrix

Hinweise

Permutationsmatrizen sind kostspielig, da sie nichts anderes sind als eine Zeilenumordnung von L, und daher wird die Verwendung von Indizes anstelle von Permutationsmatrizen dringend empfohlen, wenn die Permutation erforderlich ist. Die Beziehung im 2D-Fall wird dann einfach A = L[P, :] @ U. In höheren Dimensionen ist es besser, permute_l zu verwenden, um komplizierte Indexierungstricks zu vermeiden.

Im 2D-Fall, wenn man die Indizes hat, aber aus irgendeinem Grund dennoch die Permutationsmatrix benötigt, kann diese mit np.eye(M)[P, :] konstruiert werden.

Beispiele

>>> import numpy as np
>>> from scipy.linalg import lu
>>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
>>> p, l, u = lu(A)
>>> np.allclose(A, p @ l @ u)
True
>>> p  # Permutation matrix
array([[0., 1., 0., 0.],  # Row index 1
       [0., 0., 0., 1.],  # Row index 3
       [1., 0., 0., 0.],  # Row index 0
       [0., 0., 1., 0.]]) # Row index 2
>>> p, _, _ = lu(A, p_indices=True)
>>> p
array([1, 3, 0, 2], dtype=int32)  # as given by row indices above
>>> np.allclose(A, l[p, :] @ u)
True

Wir können auch nd-Arrays verwenden, zum Beispiel eine Demonstration mit einem 4D-Array

>>> rng = np.random.default_rng()
>>> A = rng.uniform(low=-4, high=4, size=[3, 2, 4, 8])
>>> p, l, u = lu(A)
>>> p.shape, l.shape, u.shape
((3, 2, 4, 4), (3, 2, 4, 4), (3, 2, 4, 8))
>>> np.allclose(A, p @ l @ u)
True
>>> PL, U = lu(A, permute_l=True)
>>> np.allclose(A, PL @ U)
True