scipy.linalg.

qz

scipy.linalg.qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)

QZ-Zerlegung für generalisierte Eigenwerte eines Matrizenpaares.

Die QZ-Zerlegung, auch bekannt als generalisierte Schur-Zerlegung, für ein Paar von n-mal-n-Matrizen (A,B) ist

(A,B) = (Q @ AA @ Z*, Q @ BB @ Z*)

wobei AA, BB in generalisierter Schur-Form sind, wenn BB obere Dreiecksmatrix mit nicht-negativer Diagonale und AA obere Dreiecksmatrix ist, oder für die reelle QZ-Zerlegung (output='real') blockweise obere Dreiecksmatrix mit 1x1- und 2x2-Blöcken. In diesem Fall entsprechen die 1x1-Blöcke reellen generalisierten Eigenwerten und die 2x2-Blöcke werden „standardisiert“, indem die entsprechenden Elemente von BB die Form haben

[ a 0 ]
[ 0 b ]

und das Paar der entsprechenden 2x2-Blöcke in AA und BB hat ein komplex konjugiertes Paar von generalisierten Eigenwerten. Wenn (output='complex') oder A und B komplexe Matrizen sind, bezeichnet Z’ die konjugiert Transponierte von Z. Q und Z sind unitäre Matrizen.

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(N, N) array_like

Zu zerlegende 2D-Array

B(N, N) array_like

Zu zerlegende 2D-Array

output{‘real’, ‘complex’}, optional

Konstruiert die reelle oder komplexe QZ-Zerlegung für reelle Matrizen. Standard ist ‘real’.

lworkint, optional

Größe des Arbeitsfeldes. Wenn None oder -1, wird es automatisch berechnet.

sort{None, callable, ‘lhp’, ‘rhp’, ‘iuc’, ‘ouc’}, optional

HINWEIS: DIESE EINGABE IST DERZEIT DEAKTIVIERT. Verwenden Sie stattdessen ordqz.

Gibt an, ob die oberen Eigenwerte sortiert werden sollen. Es kann eine aufrufbare Funktion übergeben werden, die für einen gegebenen Eigenwert ein boolesches Ergebnis liefert, das angibt, ob der Eigenwert nach links oben sortiert werden soll (True). Für reelle Matrizenpaare nimmt die Sortierfunktion drei reelle Argumente (alphar, alphai, beta). Der Eigenwert ist x = (alphar + alphai*1j)/beta. Für komplexe Matrizenpaare oder output=’complex’ nimmt die Sortierfunktion zwei komplexe Argumente (alpha, beta). Der Eigenwert ist x = (alpha/beta). Alternativ können Zeichenkettenparameter verwendet werden

• ‘lhp’ Linke Halbebene (x.real < 0.0)

• ‘rhp’ Rechte Halbebene (x.real > 0.0)

• ‘iuc’ Innerhalb des Einheitskreises (x*x.conjugate() < 1.0)

• ‘ouc’ Außerhalb des Einheitskreises (x*x.conjugate() > 1.0)

Standard ist None (keine Sortierung).

overwrite_abool, optional

Gibt an, ob Daten in a überschrieben werden sollen (kann die Leistung verbessern)

overwrite_bbool, optional

Ob Daten in b überschrieben werden sollen (kann die Leistung verbessern)

check_finitebool, optional

Wenn True, werden die Elemente von A und B auf endliche Zahlen überprüft. Wenn False, wird keine Prüfung durchgeführt und die Matrix wird an den zugrunde liegenden Algorithmus weitergegeben.

Rückgabe:

AA(N, N) ndarray

Generalisierte Schur-Form von A.

BB(N, N) ndarray

Generalisierte Schur-Form von B.

Q(N, N) ndarray

Die linken Schur-Vektoren.

Z(N, N) ndarray

Die rechten Schur-Vektoren.

Siehe auch

ordqz

Hinweise

Q ist transponiert im Vergleich zur äquivalenten Funktion in Matlab.

Hinzugefügt in Version 0.11.0.

Beispiele

Probieren Sie es in Ihrem Browser aus!

>>> import numpy as np
>>> from scipy.linalg import qz

>>> A = np.array([[1, 2, -1], [5, 5, 5], [2, 4, -8]])
>>> B = np.array([[1, 1, -3], [3, 1, -1], [5, 6, -2]])

Berechnet die Zerlegung. Die QZ-Zerlegung ist nicht eindeutig. Je nach verwendeter zugrunde liegender Bibliothek kann es Unterschiede bei den Vorzeichen der Koeffizienten in der folgenden Ausgabe geben.

>>> AA, BB, Q, Z = qz(A, B)
>>> AA
array([[-1.36949157, -4.05459025,  7.44389431],
       [ 0.        ,  7.65653432,  5.13476017],
       [ 0.        , -0.65978437,  2.4186015 ]])  # may vary
>>> BB
array([[ 1.71890633, -1.64723705, -0.72696385],
       [ 0.        ,  8.6965692 , -0.        ],
       [ 0.        ,  0.        ,  2.27446233]])  # may vary
>>> Q
array([[-0.37048362,  0.1903278 ,  0.90912992],
       [-0.90073232,  0.16534124, -0.40167593],
       [ 0.22676676,  0.96769706, -0.11017818]])  # may vary
>>> Z
array([[-0.67660785,  0.63528924, -0.37230283],
       [ 0.70243299,  0.70853819, -0.06753907],
       [ 0.22088393, -0.30721526, -0.92565062]])  # may vary

Verifiziert die QZ-Zerlegung. Bei reeller Ausgabe benötigen wir nur die Transponierte von Z in den folgenden Ausdrücken.

>>> Q @ AA @ Z.T  # Should be A
array([[ 1.,  2., -1.],
       [ 5.,  5.,  5.],
       [ 2.,  4., -8.]])
>>> Q @ BB @ Z.T  # Should be B
array([[ 1.,  1., -3.],
       [ 3.,  1., -1.],
       [ 5.,  6., -2.]])

Wiederholt die Zerlegung, aber mit output='complex'.

>>> AA, BB, Q, Z = qz(A, B, output='complex')

Für Kürze in der Ausgabe verwenden wir np.set_printoptions(), um die Ausgabepräzision von NumPy-Arrays auf 3 zu setzen und winzige Werte als 0 anzuzeigen.

>>> np.set_printoptions(precision=3, suppress=True)
>>> AA
array([[-1.369+0.j   ,  2.248+4.237j,  4.861-5.022j],
       [ 0.   +0.j   ,  7.037+2.922j,  0.794+4.932j],
       [ 0.   +0.j   ,  0.   +0.j   ,  2.655-1.103j]])  # may vary
>>> BB
array([[ 1.719+0.j   , -1.115+1.j   , -0.763-0.646j],
       [ 0.   +0.j   ,  7.24 +0.j   , -3.144+3.322j],
       [ 0.   +0.j   ,  0.   +0.j   ,  2.732+0.j   ]])  # may vary
>>> Q
array([[ 0.326+0.175j, -0.273-0.029j, -0.886-0.052j],
       [ 0.794+0.426j, -0.093+0.134j,  0.402-0.02j ],
       [-0.2  -0.107j, -0.816+0.482j,  0.151-0.167j]])  # may vary
>>> Z
array([[ 0.596+0.32j , -0.31 +0.414j,  0.393-0.347j],
       [-0.619-0.332j, -0.479+0.314j,  0.154-0.393j],
       [-0.195-0.104j,  0.576+0.27j ,  0.715+0.187j]])  # may vary

Bei komplexen Arrays müssen wir Z.conj().T in den folgenden Ausdrücken verwenden, um die Zerlegung zu verifizieren.

>>> Q @ AA @ Z.conj().T  # Should be A
array([[ 1.-0.j,  2.-0.j, -1.-0.j],
       [ 5.+0.j,  5.+0.j,  5.-0.j],
       [ 2.+0.j,  4.+0.j, -8.+0.j]])
>>> Q @ BB @ Z.conj().T  # Should be B
array([[ 1.+0.j,  1.+0.j, -3.+0.j],
       [ 3.-0.j,  1.-0.j, -1.+0.j],
       [ 5.+0.j,  6.+0.j, -2.+0.j]])

ZurückIn Tab öffnen