+ LV-j%|^RIHt^RIt^RIHtHt^RIHtH t ^RI H t H t R.t R Rlt]!R R R R 4R4tR#))IterableN)_asarray_validated_apply_over_batch) block_diag LinAlgError)_compute_lworkget_lapack_funcscossinc 6V'g V'Ed'Vf^M \V4pVf^M \V4p\VRR7p\P!VPRR!'g\ RVPRR 24hVPR,pW8gV^8:d$\ RV RVPR, R24hW'8gV^8:d$\ RV R VPR, R24hVR RV1RV13,VR RV1VR13,VR VR1RV13,VR VR1VR13,3wrrMT\ V\4'g \ R 4h\V4^8wd\ R \V4 24hR V4wrr\WWW4WVR7#)u Compute the cosine-sine (CS) decomposition of an orthogonal/unitary matrix. X is an ``(m, m)`` orthogonal/unitary matrix, partitioned as the following where upper left block has the shape of ``(p, q)``:: ┌ ┐ │ 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`` are square orthogonal/unitary matrices of dimensions ``(p,p)``, ``(m-p,m-p)``, ``(q,q)``, and ``(m-q,m-q)`` respectively, and ``C`` and ``S`` are ``(r, r)`` nonnegative diagonal matrices satisfying ``C^2 + S^2 = I`` where ``r = min(p, m-p, q, m-q)``. Moreover, the rank of the identity matrices are ``min(p, q) - r``, ``min(p, m - q) - r``, ``min(m - p, q) - r``, and ``min(m - p, m - q) - r`` respectively. X can be supplied either by itself and block specifications p, q or its subblocks in an iterable from which the shapes would be derived. See the examples below. The documentation is written assuming array arguments are of specified "core" shapes. However, array argument(s) of this function may have additional "batch" dimensions prepended to the core shape. In this case, the array is treated as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details. Parameters ---------- X : array_like, iterable complex unitary or real orthogonal matrix to be decomposed, or iterable of subblocks ``X11``, ``X12``, ``X21``, ``X22``, when ``p``, ``q`` are omitted. p : int, optional Number of rows of the upper left block ``X11``, used only when X is given as an array. q : int, optional Number of columns of the upper left block ``X11``, used only when X is given as an array. separate : bool, optional if ``True``, the low level components are returned instead of the matrix factors, i.e. ``(u1,u2)``, ``theta``, ``(v1h,v2h)`` instead of ``u``, ``cs``, ``vh``. swap_sign : bool, optional if ``True``, the ``-S``, ``-I`` block will be the bottom left, otherwise (by default) they will be in the upper right block. compute_u : bool, optional if ``False``, ``u`` won't be computed and an empty array is returned. compute_vh : bool, optional if ``False``, ``vh`` won't be computed and an empty array is returned. Returns ------- u : ndarray When ``compute_u=True``, contains the block diagonal orthogonal/unitary matrix consisting of the blocks ``U1`` (``p`` x ``p``) and ``U2`` (``m-p`` x ``m-p``) orthogonal/unitary matrices. If ``separate=True``, this contains the tuple of ``(U1, U2)``. cs : ndarray The cosine-sine factor with the structure described above. If ``separate=True``, this contains the ``theta`` array containing the angles in radians. vh : ndarray When ``compute_vh=True`, contains the block diagonal orthogonal/unitary matrix consisting of the blocks ``V1H`` (``q`` x ``q``) and ``V2H`` (``m-q`` x ``m-q``) orthogonal/unitary matrices. If ``separate=True``, this contains the tuple of ``(V1H, V2H)``. References ---------- .. [1] Brian D. Sutton. Computing the complete CS decomposition. Numer. Algorithms, 50(1):33-65, 2009. Examples -------- >>> 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 Same can be entered via subblocks without the need of ``p`` and ``q``. Also let's skip the computation of ``u`` >>> 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 NT) check_finitez=Cosine Sine decomposition only supports square matrices, got z invalid p=z, 0cossin..s:1bmmA..s#%)separate swap_sign compute_u compute_vh) intrrequalshape ValueError isinstancerlen_cossin) Xpqrrrrmx11x12x21x22s &&&&&&& rr r sP AAAAAA qt 4xx&&//0wwrs|n>? ? GGBK 6Q!Vz!F1772;-zJK K 6Q!Vz!F1772;-zJK KRaR! naRaR nQR! naQR n>#s 8 $ $:; ; q6Q;558VH>? ?::# 3S& ??c \.ROWW#.4F+wrV P^,^8XgK\V R24h VPwrVPwrVPW38wd\RW3 RVP 24hVPW38wd\RW3 RVP 24hW,W,8wd\RW, R W, R 24hW,p\WW#3Uu.uFp\P !V4NK up4pV'dR MR p\ VVR ,.WW#.4wpp\VWV R7pV'dRV^,RV^,/MRV/pV!RRVRVRVRVRVRVRVRVRRRV/ VBEvpppppppVPV,pV^8d\RV) RV 24hV^8d\V RV 24hV'd VV3VVV33#\VV4p\VV4p\P!\P!V44p \P!\P!V44p!\WW, W, 4p"\W4V", p#\WV , 4V", p$\W, V 4V", p%\W, W, 4V", p&\P!\P !V#V$V%V&V".4VP"R7p'\P$!W3VP"R7p(V'RV#1RV#13,V(RV#1RV#13&V#V",p)V#V",V$,p*V#V%,V&,^V",,p+V#V%,V&,^V",,V$,p,V'dV'RV$1RV$13,MV'RV$1RV$13,)V(V)V*1V+V,13&V V&,V",p)V V&,V",V%5,p*V#V",p+V#V",V%,p,V'dV'RV%1RV%13,)MV'RV%1RV%13,V(V)V*1V+V,13&V'RV&1RV&13,V(WV&,1WV&,13&V V(V#V#V",1V#V#V",13&V V(V V&,V V&,V",1V#V",V%,V&,^V",V#,V%,V&,13&T#p)V#V",p*V#V%,V&,V",p+V#V%,V&,^V",,p,V'dT!MV!)V(V)V*1V+V,13&V'dV!)MT!V(V V&,V V&,V",1V#V#V",13&VV(V3#uupi)r%r&r'r(z can't be emptyz Invalid x12 dimensions: desired z, got z Invalid x21 dimensions: desired zWThe subblocks have compatible sizes but don't form a square array (instead they form a rz5 array). This might be due to missing p, q arguments.uncsdorcsd_lwork)r$r"r#lworklrwork compute_u1 compute_u2 compute_v1t compute_v2ttransFsignszillegal value in argument z of internal z did not converge: )dtypeN)r%r&r'r()ziprranyr iscomplexobjr rtypecoderrdiagcossinmineyemaxr6zeros)-r%r&r'r(rrrrnameblockr"r#mmpmmqr$rcplxdrivercsd csd_lworkr. lwork_args_thetau1u2v1hv2hinfo method_nameUVDHcsrn11n12n21n22IdCSxsxeysyes-&&&&&&&& rr r s7c/1  ;;q>Q v_56 61 99DAyyHC yyQH;QH:F # {,- - yySH;SH:F # {,- - w!'gYay1;;< < A Ss,@A,@q",@A BDW'F%vv/@&A'*&:rjsD$B04 *A?H:z:zBZCZr)