xf5VdZddlZddlmZddlmZgdZdZ d dZ d d Z d d Z y)zQR decomposition functions.N)get_lapack_funcs) _datacopied)qr qr_multiplyrqc|jdd}|dvr?d|d<||i|}|ddjjtj|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)getrealastypenumpyint_ ValueError)fnameargskwargsr rets 9/usr/lib/python3/dist-packages/scipy/linalg/_decomp_qr.pysafecallr s JJw %E w  b'!*//00<w T V C 2w{H WHd+,- - s8Oc|dvr td|rtj|}ntj|}t |j dk7r td|j \}}|xs t ||}|r(td|f\} t| d||\} } } | dz} n"td |f\} t| d ||| \} } |d vs||krtj| }ntj| d |d d f}|r| f}n|f}|dk(r|S|dk(r| | ff|zStd| f\}||krt|d| d d d |f| |d \}nf|dk(rt|d| | |d \}nM| jj}tj||f|}| |d d d |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. 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'``. R : float or complex ndarray Of shape (M, N), or (K, N) for ``mode='economic'``. ``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,)) )fullrreconomicrawz>Mode argument should be one of ['full', 'r','economic', 'raw']zexpected a 2-D array)geqp3r!) overwrite_ar)geqrfr#r r")rrNrr)orgqrz gorgqr/gungqrrdtype) rrasarray_chkfiniteasarraylenshaperrrtriur'charempty)ar"r modepivoting check_finitea1MNr!rjpvttaur#RRj gor_un_gqrQtqqrs rrrsB 99./ /  $ $Q ' ]]1  288}/00 88DAq5+b!"4K!*re4 M D#  !*re45'2U'24C &&!a% JJrN JJr"1"a%y ! W R s{ S |b  ":u5KJ1u j/2a!e9c!q2   j/2s%"#% HHMMkk1a&*ArrE j/35"#% 4"9rc |dvrtdj|tj|}|jdkr)d}tj |}|dk(r|j }nd}tj tj|}|j\}} |dk(rT|jdt|| ||| z zzk7rptdj|j|j||jd k7r/td j|j|jt||d d |} | d\} } td | f\} | jdvrd}nd}| d d d t|| f} || kDr|dk(r|s|rGtj|jd |f|jd}|j |d d d | f<n>tj||jd f|jd}||d | d d f<d}|rd}nd}d}n;|jdr|dk(s|r|j }|dk(rd}nd}nd}|}|dk(rd}nd}t!| d||| | ||\}|dk7r |j }|dk(r|d d d t|| f}|r|j#}|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 )leftrightz8Mode argument can only be 'left' or 'right' but not '{}'r Tr?Frz=Array shapes are not compatible for Q @ c operation: {} vs {}rz=Array shapes are not compatible for c @ Q operation: {} vs {}Nr)ormqr)sdTCF)r'orderr5r8L C_CONTIGUOUSz gormqr/gunmqr) overwrite_cr@)rformatrr(ndim atleast_2drDr)r+minrrtypecodezerosr'flagsrravel)r/cr0r1 conjugater"rJonedimr4r5rr;r7 gor_un_mqrtranscclrcQs rrrsX $$$$*F4L2 2 "Avvz   Q  6>A q)*A 77DAq v~ 771:QK1$5 56 644:F177AGG4LN N  ?44:F177AGG4LN N Q T5( 3C VFAs":t4KJj( !Zc!QiZ-A1u aggaj!_AGG3GBBq"1"uIa_AGG3GBBrr1uIE BB  Uc\Y SS 6>BB  6>BB :E1c2* ,CB | TT w :C1I:  XXZ 53qr7?rc|dvr td|rtj|}ntj|}t |j dk7r td|j \}}|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 data in a is overwritten (may improve performance) 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)) )rrrz8Mode argument should be one of ['full', 'r', 'economic']r zexpected matrix)gerqfr\r$rNr)orgrqz gorgrq/gungrqrr&) rrr(r)r*r+rrrr,r.r')r/r"r r0r2r3r4r5r\rr7r8 gor_un_grqr;rq1s rrrFsB ,,KM M  $ $Q ' ]]1  288}*++ 88DAq5+b!"4K j2% 0FEugr#.0GB : Q JJr1Q3  JJr1"#rs(| $ s{":u5KJ1u j/2qbc7Cu"#% a4K   j/2s%"#% a4K kk1a&1QBC j/35"#% a4Kr)FNrFT)r@FFFF)FNrT) __doc__rlapackr_miscr__all__rrrrrrresD! % % @EUp?D/4Qhgr