UgM: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 V/var/www/surfInsights/venv3-11/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)aG 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. 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 >>> 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,)) )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 rrrsD 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 rrrfsB ,,,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!!%$$$$$ % % %   @Eqqqqh?D/4UUUUpyyyyyyr