scipy.linalg.

cossin#

scipy.linalg.cossin(X, p=None, q=None, separate=False, swap_sign=False, compute_u=True, compute_vh=True)[Quelle]#

Berechnet die Kosinus-Sinus-Zerlegung (CS-Zerlegung) einer orthogonalen/unitären Matrix.

X ist eine (m, m) orthogonale/unitäre Matrix, die wie folgt partitioniert ist, wobei der obere linke Block die Form (p, q) hat.

                           ┌                   ┐
                           │ I  0  0 │ 0  0  0 │
┌           ┐   ┌         ┐│ 0  C  0 │ 0 -S  0 │┌         ┐*
│ X11 │ X12 │   │ U1 │    ││ 0  0  0 │ 0  0 -I ││ V1 │    │
│ ────┼──── │ = │────┼────││─────────┼─────────││────┼────│
│ X21 │ X22 │   │    │ U2 ││ 0  0  0 │ I  0  0 ││    │ V2 │
└           ┘   └         ┘│ 0  S  0 │ 0  C  0 │└         ┘
                           │ 0  0  I │ 0  0  0 │
                           └                   ┘

U1, U2, V1, V2 sind quadratische orthogonale/unitäre Matrizen der Dimensionen (p,p), (m-p,m-p), (q,q) und (m-q,m-q), und C und S sind (r, r) nicht-negative Diagonalmatrizen, die C^2 + S^2 = I erfüllen, wobei r = min(p, m-p, q, m-q).

Außerdem sind die Ränge der Identitätsmatrizen min(p, q) - r, min(p, m - q) - r, min(m - p, q) - r und min(m - p, m - q) - r.

X kann entweder allein mit den Blockspezifikationen p, q oder seinen Unterblöcken in einem Iterable übergeben werden, aus dem die Formen abgeleitet werden. Siehe die folgenden Beispiele.

Parameter:
Xarray_like, iterable

komplexe unitäre oder reelle orthogonale Matrix, die zerlegt werden soll, oder ein Iterable von Unterblöcken X11, X12, X21, X22, wenn p und q weggelassen werden.

pint, optional

Anzahl der Zeilen des oberen linken Blocks X11, wird nur verwendet, wenn X als Array übergeben wird.

qint, optional

Anzahl der Spalten des oberen linken Blocks X11, wird nur verwendet, wenn X als Array übergeben wird.

separatebool, optional

Wenn True, werden die Low-Level-Komponenten anstelle der Matrixfaktoren zurückgegeben, d.h. (u1,u2), theta, (v1h,v2h) anstelle von u, cs, vh.

swap_signbool, optional

Wenn True, befindet sich der Block -S, -I unten links, andernfalls (standardmäßig) befinden sie sich im oberen rechten Block.

compute_ubool, optional

Wenn False, wird u nicht berechnet und ein leeres Array zurückgegeben.

compute_vhbool, optional

Wenn False, wird vh nicht berechnet und ein leeres Array zurückgegeben.

Rückgabe:
undarray

Wenn compute_u=True, enthält die blockdiagonale orthogonale/unitäre Matrix, die aus den Blöcken U1 (p x p) und U2 (m-p x m-p) orthogonalen/unitären Matrizen besteht. Wenn separate=True, enthält dies das Tupel von (U1, U2).

csndarray
Der Kosinus-Sinus-Faktor mit der oben beschriebenen Struktur.

Wenn separate=True, enthält dies das theta-Array, das die Winkel in Radiant enthält.

vhndarray

Wenn compute_vh=True`, enthält die blockdiagonale orthogonale/unitäre Matrix, die aus den Blöcken ``V1H (q x q) und V2H (m-q x m-q) orthogonalen/unitären Matrizen besteht. Wenn separate=True, enthält dies das Tupel von (V1H, V2H).

Hinweise

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.

Referenzen

[1]

Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009.

Beispiele

>>> import numpy as np
>>> from scipy.linalg import cossin
>>> from scipy.stats import unitary_group
>>> x = unitary_group.rvs(4)
>>> u, cs, vdh = cossin(x, p=2, q=2)
>>> np.allclose(x, u @ cs @ vdh)
True

Dasselbe kann über Unterblöcke eingegeben werden, ohne dass p und q benötigt werden. Lassen Sie uns auch die Berechnung von u überspringen.

>>> ue, cs, vdh = cossin((x[:2, :2], x[:2, 2:], x[2:, :2], x[2:, 2:]),
...                      compute_u=False)
>>> print(ue)
[]
>>> np.allclose(x, u @ cs @ vdh)
True