scipy.linalg.

schur#

scipy.linalg.schur(a, output='real', lwork=None, overwrite_a=False, sort=None, check_finite=True)[Quelle]#

Berechnet die Schur-Zerlegung einer Matrix.

Die Schur-Zerlegung ist

A = Z T Z^H

wobei Z unitär und T entweder eine obere Dreiecksmatrix oder für die reelle Schur-Zerlegung (output='real') eine quasi-obere Dreiecksmatrix ist. In der quasi-dreieckigen Form können 2x2-Blöcke, die komplexwertige Eigenwertpaare beschreiben, aus der Diagonalen herausragen.

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, M) array_like

Zu zerlegende Matrix

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

Wenn der dtype von a reell ist, gibt dies an, ob die reelle oder komplexe Schur-Zerlegung berechnet werden soll. Wenn der dtype von a komplex ist, wird dieses Argument ignoriert und die komplexe Schur-Zerlegung berechnet.

lworkint, optional

Größe des Arbeitsarrays. Wenn None oder -1, wird sie automatisch berechnet.

overwrite_abool, optional

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

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

Gibt an, ob die oberen Eigenwerte sortiert werden sollen. Ein Callable kann übergeben werden, das, gegeben einen Eigenwert, einen booleschen Wert zurückgibt, der angibt, ob der Eigenwert oben links sortiert werden soll (True).

  • Wenn output='complex' ODER der dtype von a komplex ist, sollte das Callable ein Argument haben: den Eigenwert, ausgedrückt als komplexe Zahl.

  • Wenn output='real' UND der dtype von a reell ist, sollte das Callable zwei Argumente haben: den Real- und den Imaginärteil des Eigenwerts.

Alternativ können Zeichenkettenparameter verwendet werden

'lhp'   Left-hand plane (real(eigenvalue) < 0.0)
'rhp'   Right-hand plane (real(eigenvalue) >= 0.0)
'iuc'   Inside the unit circle (abs(eigenvalue) <= 1.0)
'ouc'   Outside the unit circle (abs(eigenvalue) > 1.0)

Standard ist None (keine Sortierung).

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:
T(M, M) ndarray

Schur-Form von A. Sie ist reellwertig für die reelle Schur-Zerlegung.

Z(M, M) ndarray

Eine unitäre Schur-Transformationmatrix für A. Sie ist reellwertig für die reelle Schur-Zerlegung.

sdimint

Wenn und nur wenn eine Sortierung angefordert wurde, enthält ein drittes Rückgabeformat die Anzahl der Eigenwerte, die die Sortierungsbedingung erfüllen. Beachten Sie, dass komplex konjugierte Paare, für die die Bedingung für einen der Eigenwerte wahr ist, als 2 gezählt werden.

Löst aus:
LinAlgError

Fehler wird unter drei Bedingungen ausgelöst

  1. Der Algorithmus schlug fehl, da der QR-Algorithmus alle Eigenwerte nicht berechnen konnte.

  2. Wenn eine Sortierung der Eigenwerte angefordert wurde, konnten die Eigenwerte aufgrund eines Fehlers bei der Trennung von Eigenwerten, normalerweise aufgrund schlechter Konditionierung, nicht neu geordnet werden.

  3. Wenn eine Sortierung der Eigenwerte angefordert wurde, führten Rundungsfehler dazu, dass die führenden Eigenwerte die Sortierungsbedingung nicht mehr erfüllten.

Siehe auch

rsf2csf

Konvertiert reelle Schur-Form in komplexe Schur-Form

Beispiele

>>> import numpy as np
>>> from scipy.linalg import schur, eigvals
>>> A = np.array([[0, 2, 2], [0, 1, 2], [1, 0, 1]])
>>> T, Z = schur(A)
>>> T
array([[ 2.65896708,  1.42440458, -1.92933439],
       [ 0.        , -0.32948354, -0.49063704],
       [ 0.        ,  1.31178921, -0.32948354]])
>>> Z
array([[0.72711591, -0.60156188, 0.33079564],
       [0.52839428, 0.79801892, 0.28976765],
       [0.43829436, 0.03590414, -0.89811411]])

>>> T2, Z2 = schur(A, output='complex')
>>> T2
array([[ 2.65896708, -1.22839825+1.32378589j,  0.42590089+1.51937378j], # may vary
       [ 0.        , -0.32948354+0.80225456j, -0.59877807+0.56192146j],
       [ 0.        ,  0.                    , -0.32948354-0.80225456j]])
>>> eigvals(T2)
array([2.65896708, -0.32948354+0.80225456j, -0.32948354-0.80225456j])   # may vary

Eine benutzerdefinierte Bedingung zur Sortierung von Eigenwerten, die nach dem positiven Imaginärteil sortiert, wird von nur einem Eigenwert erfüllt.

>>> _, _, sdim = schur(A, output='complex', sort=lambda x: x.imag > 1e-15)
>>> sdim
1

Wenn output='real' und das Array a reell ist, muss das Callable sort den Real- und Imaginärteil als separate Argumente akzeptieren. Beachten Sie, dass die komplexen Eigenwerte -0.32948354+0.80225456j und -0.32948354-0.80225456j nun als komplex konjugiertes Paar behandelt werden und gemäß der Dokumentation von sdim komplex konjugierte Paare, für die die Bedingung für *einen* der Eigenwerte wahr ist, sdim um *zwei* erhöhen.

>>> _, _, sdim = schur(A, output='real', sort=lambda x, y: y > 1e-15)
>>> sdim
2
Auf dieser Seite