^j@dZddlZddlmZmZddlmZddlZddl m Z m Z m Z ddl mZddlmZdd lmZgd Zd Zd ed d dfdZedd ddZedddZy)zQR decomposition functions.N)_apply_over_batch_deprecate_dtypes)_NoValue)_normalize_lapack_dtypeget_lapack_funcs HAS_ILP64) _datacopied)_format_emit_errors_warnings)_batched_linalg)qr qr_multiplyrqc|jdd}|dvr?d|d<||i|}|ddjjtj|d<||i|}|ddkrt d|d d||ddS) z[Call a LAPACK routine, determining lwork automatically and handling error return valueslworkN)Nrrzillegal value in zth argument of internal )getrealastypenpint_ ValueError)fnameargskwargsrrets P/opt/ringagent/.cad-venv/lib/python3.12/site-packages/scipy/linalg/_decomp_qr.pysafecallr s JJw %E w  b'!*//009w T V C 2w{,c"gXJ6NtfUVV s8OFfullTcPdddddd}||jvr%tdt|j||}|rtj|}ntj |}t d||jdkr td |jd |jd } } |tur6||d k7r|| krtd |tjdtdt||\}}|jdk(r|tj$| t&rtj(ntj*f}n|f}|dk(r|S|dk(r?tj || | | fz}tj,|| | fz}||ff|zS| f|zS|j.dr|j0j2dk(sd}|j5}|xs t7||}|xr |jdk(xr|j.d}t9j:||||\} }}}}|r t=||r||f}n|f}||dk(r| |f} n||dk(r| | kr | dd d d | f} ||dk(r|S| f|zS)a Compute QR decomposition of a matrix. Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal and R upper triangular. Parameters ---------- a : (..., M, N) array_like Matrix to be decomposed overwrite_a : bool, optional Whether to overwrite data in `a` (may improve performance). Default is False. See :ref:`tutorial_linalg_overwrite` for details. lwork : int, optional Work array size, lwork >= a.shape[1]. If None or -1, an optimal size is computed. .. deprecated:: 1.18.0 This keyword is deprecated as well as no longer in use and will be removed in 1.20.0. mode : {'full', 'r', 'economic', 'raw'}, optional Determines what information is to be returned: either both Q and R ('full', default), only R ('r') or both Q and R but computed in economy-size ('economic', see Notes). The final option 'raw' (added in SciPy 0.11) makes the function return two matrices (Q, TAU) in the internal format used by LAPACK. pivoting : bool, optional Whether or not factorization should include pivoting for rank-revealing qr decomposition. If pivoting, compute the decomposition ``A[..., :, P] = Q @ R`` as above, but where P is chosen such that the diagonal of R is non-increasing. Equivalently, albeit less efficiently, an explicit P matrix may be formed explicitly by permuting the rows or columns (depending on the side of the equation on which it is to be used) of an identity matrix. See Examples. check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- Q : float or complex ndarray Of shape (..., M, M), or (..., M, K) for ``mode='economic'``. Not returned if ``mode='r'``. Replaced by tuple ``(Q, TAU)`` if ``mode='raw'``. R : float or complex ndarray Of shape (..., M, N), or (..., K, N) for ``mode in ['economic', 'raw']``. ``K = min(M, N)``. P : int ndarray Of shape (..., N,) for ``pivoting=True``. Not returned if ``pivoting=False``. Raises ------ LinAlgError Raised if decomposition fails Notes ----- This is an interface to the LAPACK routines dgeqrf, zgeqrf, dorgqr, zungqr, dgeqp3, and zgeqp3. If ``mode=economic``, the shapes of Q and R are (..., M, K) and (..., K, N) instead of (..., M,M) and (..., M,N), with ``K=min(M,N)``. Examples -------- >>> import numpy as np >>> from scipy import linalg >>> rng = np.random.default_rng() >>> a = rng.standard_normal((9, 6)) >>> q, r = linalg.qr(a) >>> np.allclose(a, np.dot(q, r)) True >>> q.shape, r.shape ((9, 9), (9, 6)) >>> r2 = linalg.qr(a, mode='r') >>> np.allclose(r, r2) True >>> q3, r3 = linalg.qr(a, mode='economic') >>> q3.shape, r3.shape ((9, 6), (6, 6)) >>> q4, r4, p4 = linalg.qr(a, pivoting=True) >>> d = np.abs(np.diag(r4)) >>> np.all(d[1:] <= d[:-1]) True >>> np.allclose(a[:, p4], np.dot(q4, r4)) True >>> P = np.eye(p4.size)[p4] >>> np.allclose(a, np.dot(q4, r4) @ P) True >>> np.allclose(a @ P.T, np.dot(q4, r4)) True >>> q4.shape, r4.shape, p4.shape ((9, 9), (9, 6), (6,)) >>> q5, r5, p5 = linalg.qr(a, mode='economic', pivoting=True) >>> q5.shape, r5.shape, p5.shape ((9, 6), (6, 6), (6,)) >>> P = np.eye(6)[:, p5] >>> np.allclose(a @ P, np.dot(q5, r5)) True r )r"r rraweconomiczMode argument should be one of z linalg.qrzExpected at least a 2-D arrayrrNz%lwork should be None, -1 or > M, got z{scipy.linalg: the `lwork` keyword is deprecated and no longer in use as of SciPy 1.18.0 and will be removed in SciPy 1.20.0) stacklevelr)r)r(shape.dtyper'r(ALIGNED=T F_CONTIGUOUSr))keysrlistrasarray_chkfiniteasarrayrndimr-rwarningswarnDeprecationWarningrsizemin empty_likeidentityaranger int64int32 zeros_likeflagsr/ byteordercopyr r _qrr )a overwrite_armodepivoting check_finitemodesmodeFlaga1MNK batch_shapeQRRjr taujpvterr_lsts rr r s,^   E 5::<:4 ;M:NOPPT{H  ! !! $ ZZ]k2& ww{899 88B<"qA H  "!DUGLM M MMJ"  .b+>OB  ww!| 1Ihhsm * * b q!f(<=A;;q>Ac1aiL b!A b q!f(<=A b q!f(<=A BIIa9rxx"((KKBB 3;I U]r1v)=>B--+*<=CI<"$ $tby HHY BHH$6$6#$= WWY5+b!"4KM277a<MRXXn5MK /222{HhWAq#tW$W- WT5< H U:& &1q5 c1bqbjM5: tbyr!)rGr*)cz1|2c |dvrtd|dtj|}|jdkr)d}tj|}|dk(r|j }nd}tjtj |}|j\}} |dk(rJ|jdt|| ||| z zzk7r\td |jd |j||jd k7r%td |jd |jt||d |} | d\} } |jdk(rtj|f| d dzStd| f\} | jdvrd}nd}| dddt|| f} || kDr|dk(r|s|rGtj|jd |f|jd}|j |ddd| f<n>tj||jd f|jd}||d| ddf<d}|rd}nd}d}n;|j dr|dk(s|r|j }|dk(rd}nd}nd}|}|dk(rd}nd}t#| d||| | ||\}|dk7r |j }|dk(r|dddt|| f}|r|j%}|f| d dzS)a3 Calculate the QR decomposition and multiply Q with a matrix. Calculate the decomposition ``A = Q R`` where Q is unitary/orthogonal and R upper triangular. Multiply Q with a vector or a matrix c. Parameters ---------- a : (M, N), array_like Input array c : array_like Input array to be multiplied by ``q``. mode : {'left', 'right'}, optional ``Q @ c`` is returned if mode is 'left', ``c @ Q`` is returned if mode is 'right'. The shape of c must be appropriate for the matrix multiplications, if mode is 'left', ``min(a.shape) == c.shape[0]``, if mode is 'right', ``a.shape[0] == c.shape[1]``. pivoting : bool, optional Whether or not factorization should include pivoting for rank-revealing qr decomposition, see the documentation of qr. conjugate : bool, optional Whether Q should be complex-conjugated. This might be faster than explicit conjugation. overwrite_a : bool, optional Whether to overwrite data in `a` (may improve performance). Default is False. See :ref:`tutorial_linalg_overwrite` for details. overwrite_c : bool, optional Whether data in c is overwritten (may improve performance). If this is used, c must be big enough to keep the result, i.e. ``c.shape[0]`` = ``a.shape[0]`` if mode is 'left'. See :ref:`tutorial_linalg_overwrite` for details. Returns ------- CQ : ndarray The product of ``Q`` and ``c``. R : (K, N), ndarray R array of the resulting QR factorization where ``K = min(M, N)``. P : (N,) ndarray Integer pivot array. Only returned when ``pivoting=True``. Raises ------ LinAlgError Raised if QR decomposition fails. Notes ----- This is an interface to the LAPACK routines ``?GEQRF``, ``?ORMQR``, ``?UNMQR``, and ``?GEQP3``. .. versionadded:: 0.11.0 Examples -------- >>> import numpy as np >>> from scipy.linalg import qr_multiply, qr >>> A = np.array([[1, 3, 3], [2, 3, 2], [2, 3, 3], [1, 3, 2]]) >>> qc, r1, piv1 = qr_multiply(A, 2*np.eye(4), pivoting=1) >>> qc array([[-1., 1., -1.], [-1., -1., 1.], [-1., -1., -1.], [-1., 1., 1.]]) >>> r1 array([[-6., -3., -5. ], [ 0., -1., -1.11022302e-16], [ 0., 0., -1. ]]) >>> piv1 array([1, 0, 2], dtype=int32) >>> q2, r2, piv2 = qr(A, mode='economic', pivoting=1) >>> np.allclose(2*q2 - qc, np.zeros((4, 3))) True )leftrightz5Mode argument can only be 'left' or 'right' but not ''r*Tr[Frz5Array shapes are not compatible for Q @ c operation: z vs rz5Array shapes are not compatible for c @ Q operation: r()rIrJN)ormqr)sdTCF)r/orderrPrTL C_CONTIGUOUSz gormqr/gunmqr) overwrite_cr\)rrr5r7 atleast_2drar6r-r<r r;r=rtypecodezerosr/rCr ravel)rGrYrIrJ conjugaterHrgonedimrOrPr(rSrV gor_un_mqrtranscclrcQs rrrs^ $$!!%a)* * QAvvz MM!  6>A bjjm$A 77DAq v~ 771:QK1$5 56 6,,-GG9D CD D  ?,,-GG9D CD D Q %( ;C VFAs vv{ a "SW,,":t4KJj( !Zc!QiZ-A1u 1771:q/DBBq"1"uI1aggaj/DBBrr1uIE BB  Uc\Y SS 6>BB  6>BB :E1c2* ,CB | TT w :C1I:  XXZ 53qr7?r!c6|dvr td|rtj|}ntj|}t |j dk7r td|j \}}|j dk(rt||}|dk(sGtj|} tj|||f} tj|| d<n2tj|||f} tj|||f} |d k(r| S| | fS|xs t||}td |f\} t| d ||| \} } |dk(r||krtj| ||z } n tj| | d | d f} |d k(r| Std| f\}||krt|d| | d | |d \} | | fS|dk(rt|d| | |d \} | | fStj||f| j}| || d t|d|| |d \} | | fS)a, Compute RQ decomposition of a matrix. Calculate the decomposition ``A = R Q`` where Q is unitary/orthogonal and R upper triangular. Parameters ---------- a : (M, N) array_like Matrix to be decomposed overwrite_a : bool, optional Whether to overwrite data in `a` (may improve performance). Default is False. See :ref:`tutorial_linalg_overwrite` for details. lwork : int, optional Work array size, lwork >= a.shape[1]. If None or -1, an optimal size is computed. mode : {'full', 'r', 'economic'}, optional Determines what information is to be returned: either both Q and R ('full', default), only R ('r') or both Q and R but computed in economy-size ('economic', see Notes). check_finite : bool, optional Whether to check that the input matrix contains only finite numbers. Disabling may give a performance gain, but may result in problems (crashes, non-termination) if the inputs do contain infinities or NaNs. Returns ------- R : float or complex ndarray Of shape (M, N) or (M, K) for ``mode='economic'``. ``K = min(M, N)``. Q : float or complex ndarray Of shape (N, N) or (K, N) for ``mode='economic'``. Not returned if ``mode='r'``. Raises ------ LinAlgError If decomposition fails. Notes ----- This is an interface to the LAPACK routines sgerqf, dgerqf, cgerqf, zgerqf, sorgrq, dorgrq, cungrq and zungrq. If ``mode=economic``, the shapes of Q and R are (K, N) and (M, K) instead of (N,N) and (M,N), with ``K=min(M,N)``. Examples -------- >>> import numpy as np >>> from scipy import linalg >>> rng = np.random.default_rng() >>> a = rng.standard_normal((6, 9)) >>> r, q = linalg.rq(a) >>> np.allclose(a, r @ q) True >>> r.shape, q.shape ((6, 9), (9, 9)) >>> r2 = linalg.rq(a, mode='r') >>> np.allclose(r, r2) True >>> r3, q3 = linalg.rq(a, mode='economic') >>> r3.shape, q3.shape ((6, 6), (6, 9)) )r"r'r)z8Mode argument should be one of ['full', 'r', 'economic']r*zexpected matrixrr)r,.r')gerqfrt)rrHN)orgrqz gorgrq/gungrqrr.)rrr5r6lenr-r;r<r=r>r rr triuemptyr/)rGrHrrIrKrNrOrPrQrTrSrtrrV gor_un_grqrq1s rrrs=F ,,KM M  ! !! $ ZZ] 288}*++ 88DAq ww!| 1Iz! b!A bA/A[[^AcF bA/A bA/A 3;H!t 5+b!"4K j2% 0FEugr#.0GB : Q GGB!  GGBrsQBCxL ! s{":u5KJ1u j/2qbc7Cu"#% a4K   j/2s%"#% a4K hh1vRXX.QBC j/35"#% a4Kr!)r\FFFF)FNr"T)__doc__numpyrscipy._lib._utilrrscipy._lib.deprecationrr8lapackrrr _miscr _basicr r __all__r r rrr!rrs!A+IH0 % 8&5Pf8\*>C/4W+Wt8zzr!