scipy.linalg.

qz#

scipy.linalg.qz(A, B, output='real', lwork=None, sort=None, overwrite_a=False, overwrite_b=False, check_finite=True)[原始碼]#

廣義特徵值矩陣對的 QZ 分解。

對於 n 乘 n 矩陣 (A,B) 對，QZ 或廣義 Schur 分解為

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

其中 AA、BB 呈廣義 Schur 形式，如果 BB 是具有非負對角線的上三角矩陣，且 AA 是上三角矩陣，或者對於實數 QZ 分解 (output='real') 區塊上三角矩陣，具有 1x1 和 2x2 區塊。在這種情況下，1x1 區塊對應於實數廣義特徵值，而 2x2 區塊通過使 BB 的相應元素具有以下形式來「標準化」

[ a 0 ]
[ 0 b ]

且 AA 和 BB 中對應的 2x2 區塊將具有一對複共軛廣義特徵值。如果 (output='complex') 或 A 和 B 是複數矩陣，則 Z’ 表示 Z 的共軛轉置。Q 和 Z 是么正矩陣。

參數:

A(N, N) 類陣列

要分解的 2-D 陣列

B(N, N) 類陣列

要分解的 2-D 陣列

output{‘real’, ‘complex’}, 選項性

為實數矩陣建構實數或複數 QZ 分解。預設為 ‘real’。

lwork整數，選項性

工作陣列大小。如果為 None 或 -1，則會自動計算。

sort{None, 可呼叫物件, ‘lhp’, ‘rhp’, ‘iuc’, ‘ouc’}, 選項性

注意：此輸入目前已停用。請改用 ordqz。

指定是否應排序上特徵值。可以傳遞可呼叫物件，給定一個特徵值，返回一個布林值，表示是否應將特徵值排序到左上方 (True)。對於實數矩陣對，排序函數接受三個實數引數 (alphar, alphai, beta)。特徵值 x = (alphar + alphai*1j)/beta。對於複數矩陣對或 output=’complex’，排序函數接受兩個複數引數 (alpha, beta)。特徵值 x = (alpha/beta)。或者，可以使用字串參數

‘lhp’ 左半平面 (x.real < 0.0)

‘rhp’ 右半平面 (x.real > 0.0)

‘iuc’ 單位圓內 (x*x.conjugate() < 1.0)

‘ouc’ 單位圓外 (x*x.conjugate() > 1.0)

預設為 None (不排序)。

overwrite_a布林值，選項性

是否覆寫 a 中的資料 (可能提高效能)

overwrite_b布林值，選項性

是否覆寫 b 中的資料 (可能提高效能)

check_finite布林值，選項性

如果為 true，則檢查 A 和 B 的元素是否為有限數字。如果為 false，則不執行檢查並將矩陣傳遞到基礎演算法。

返回:

AA(N, N) ndarray: A 的廣義 Schur 形式。
BB(N, N) ndarray: B 的廣義 Schur 形式。
Q(N, N) ndarray: 左 Schur 向量。
Z(N, N) ndarray: 右 Schur 向量。

另請參閱

ordqz

註解

Q 相對於 Matlab 中的等效函數是轉置的。

在 0.11.0 版本中新增。

範例

>>> 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]])

計算分解。QZ 分解不是唯一的，因此根據使用的基礎函式庫，以下輸出中的係數符號可能存在差異。

>>> 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

驗證 QZ 分解。對於實數輸出，我們只需要以下運算式中 Z 的轉置。

>>> 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.]])

重複分解，但使用 output='complex'。

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

為了輸出的簡潔性，我們使用 np.set_printoptions() 將 NumPy 陣列的輸出精度設定為 3，並將微小值顯示為 0。

>>> 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

對於複數陣列，我們必須在以下運算式中使用 Z.conj().T 來驗證分解。

>>> 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]])