^Mh<XdZddlZddlmZddlmZgdZdZ dd Z dd Z ddZ dS)zQR decomposition functions.N)get_lapack_funcs) _datacopied)qr qr_multiplyrqc(|dd}|dvr@d|d<||i|}|ddjtj|d<||i|}|ddkrt d|d |fz|ddS)z[Call a LAPACK routine, determining lwork automatically and handling error return valueslworkN)Nr rz-illegal value in %dth argument of internal %s)getrealastypenpint_ ValueError)fnameargskwargsr rets W/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/scipy/linalg/_decomp_qr.pysafecallr s JJw % %E wa   b'!*/0099w !T V  C 2w{{H WHd+,-- - ss8OFfullTc|dvrtd|rtj|}ntj|}t |jdkrtd|j\}}|jdkrt||} |dvrDtj|||f} tj || d<tj|} n0tj||| f} tj|| |f} |r#| tj |tj f} n| f} |d kr| S|d kr7tj|||f} tj || f}| |ff| zS| f| zS|pt||}|r0td |f\}t|d ||\} }}|dz}n*td|f\}t|d|||\} }|dvs||krtj| } n tj| d|ddf} |r| |f} n| f} |d kr| S|d kr| |ff| zStd| f\}||kr$t|d| ddd|f||d\} nd|dkrt|d| ||d\} nF| jj}tj||f| }| |ddd|f<t|d|||d\} | 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 data in `a` is overwritten (may improve performance if `overwrite_a` is set to True by reusing the existing input data structure rather than creating a new one.) lwork : int, optional Work array size, lwork >= a.shape[1]. If None or -1, an optimal size is computed. 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 )rrreconomicrawz?Mode argument should be one of ['full', 'r', 'economic', 'raw']zexpected a 2-D arrayr)rrshape.dtyperr)geqp3r%) overwrite_ar)geqrfr'r r&N)orgqrz gorgqr/gungqrr)rrasarray_chkfiniteasarraylenr"sizemin empty_likeidentityarangeint32 zeros_likerrrtriur$charempty)ar&r modepivoting check_finitea1MNKQRRjrtaur%jpvtr' gor_un_gqrtqqrs rrrsZ 999.// /  !! $ $ Z]] 28}}/000 8DAq w!|| 1II * * * bA///A[^^AcF b!!AA bA///A bA///A  BIarx0000BBB 3;;I U]]r!Q000B-1$///CI<"$ $tby5+b!"4"4K4!*re44 MMM D#  !*re445'2U'2444C &&&!a%% GBKK GBrr111uI   W R s{{ S |b  ":u55KJ1uu j/2aaa!e9c!q222    j/2s%"#%%% HMh1vQ'''AAArrE j/35"#%%% 4"9rrightc ||dvrtd|dtj|}|jdkr$d}tj|}|dkr|j}nd}tjtj|}|j\}} |dkrH|jdt|| ||| z zzkrtd |jd |jn0||jd krtd |jd |jt||d d|} | d\} } |j dkr tj |f| d d zStd| f\} | j dvrd}nd}| d d d t|| f} || kr|dkr~|s||r:tj|jd |f|jd}|j|d d d | f<n6tj||jd f|jd}||d | d d f<d}|rd}nd}d}n7|jdr|dks|r|j}|dkrd}nd}nd}|}|dkrd}nd}t#| d||| | ||\}|dkr|j}|dkr|d d d t|| f}|r|}|f| d d zS)a 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 data in a is overwritten (may improve performance) 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'. 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 )leftrGz5Mode argument can only be 'left' or 'right' but not ''r TrIFrz5Array shapes are not compatible for Q @ c operation: z vs rz5Array shapes are not compatible for c @ Q operation: Nr)ormqr)sdTCF)r$orderr=r@L C_CONTIGUOUSz gormqr/gunmqr) overwrite_crG)rrr*ndim atleast_2drNr+r"r.rr-r/rtypecodezerosr$flagsrravel)r7cr8r9 conjugater&rTonedimr<r=rr?rB gor_un_mqrtranscclrcQs rrrsX $$$)!%)))** * QAvzz M!   6>>A bjmm$$A 7DAq v~~ 71:QK1$5 566 6 6C,-GCC9:CCDD D 7  ??C,-GCC9:CCDD D Q T5( 3 3C VFAs v{{ a  "SW,,":t44KJj(( !!!Zc!QiiZ-A1uu   171:q/DDDBBqqq"1"uII1agaj/DDDBBrr111uIE  BBB  Uc\\Y\ S 6>>BBBB  6>>BBB :E1c2* , , ,CB || T w :C1II:   XXZZ 53qrr7?rch|dvrtd|rtj|}ntj|}t |jdkrtd|j\}}|jdkrt||}|dksDtj|} tj|||f} tj || d<n0tj|||f} tj|||f} |d kr| S| | fS|pt||}td |f\} t| d ||| \} } |dkr||krtj | ||z } n"tj | | d | d f} |d kr| Std| f\}||kr!t|d| | d | |d \} nZ|dkrt|d| | |d \} n= 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)) )rrrz8Mode argument should be one of ['full', 'r', 'economic']r zexpected matrixrrr!.r)gerqfrdr(N)orgrqz gorgrq/gungrqrr#)rrr*r+r,r"r-r.r/r0rrrr4r6r$)r7r&r r8r:r;r<r=r>r@r?rdrrB gor_un_grqrq1s rrrqsB ,,,KMM M  !! $ $ Z]] 28}}*+++ 8DAq w!|| 1IIz!! b!!A bA///A[^^AcFF bA///A bA///A 3;;H!t 5+b!"4"4K j2% 0 0FEugr#.000GB :  Q GB!   GBrssQBCCxL ! ! s{{":u55KJ1uu j/2qbcc7Cu"#%%%    j/2s%"#%%%h1vRX...QBCC j/35"#%%% a4Kr)FNrFT)rGFFFF)FNrT) __doc__numpyrlapackr_miscr__all__rrrrrrrns!!%$$$$$ % % %   @E||||~?D/4UUUUpyyyyyyr