a CCCf5@sVdZddlZddlmZddlmZgdZddZdd d ZdddZ dddZ dS)zQR decomposition functions.N)get_lapack_funcs) _datacopied)qr qr_multiplyrqcOs|dd}|dvrDd|d<||i|}|ddjtj|d<||i|}|ddkrttd|d |f|ddS)z[Call a LAPACK routine, determining lwork automatically and handling error return valueslworkN)Nr rz-illegal value in %dth argument of internal %s)getrealZastypenumpyint_ ValueError)fnameargskwargsrretrS/var/www/html/django/DPS/env/lib/python3.9/site-packages/scipy/linalg/_decomp_qr.pysafecall s   rFfullTcCs|dvrtd|r t|}n t|}t|jdkr@td|j\}}|pVt||}|rtd|f\} t| d||d\} } } | d8} n$td |f\} t| d |||d \} } |d vs||krt | }nt | d |d d f}|r|| f}n|f}|dkr|S|dkr| | ff|Std| f\}||kr^t|d| d d d |f| |dd \}nf|dkrt|d| | |dd \}nD| j j }tj ||f|d}| |d d d |f<t|d|| |dd \}|f|S)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 array)geqp3r) overwrite_ar)geqrfrrr)rrNrr)Zorgqrz gorgqr/gungqrrdtype) rr asarray_chkfiniteasarraylenshaperrrtriur"charempty)arrmodepivoting check_finitea1MNrrZjpvttaurRZRjZ gor_un_gqrQtZqqrrrrrsVb                rrightc Cs|dvrtd|dt|}|jdkrJd}t|}|dkrN|j}nd}tt|}|j\}} |dkr|jdt|| ||| krtd |jd |jn&||jd krtd |jd |jt ||d d|} | d\} } t d| f\} | j dvr d}nd}| d d d t|| f} || kr|dkr|s|r~tj |jd |f|j dd}|j|d d d | f<n4tj ||jd f|j dd}||d | d d f<d}|rd}nd}d}nT|jdr|dks|r|j}|dkrd}nd}nd}|}|dkrd}nd}t| d||| | ||d\}|dkrF|j}|dkrj|d d d t|| f}|rx|}|f| d d S)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 )leftr5z5Mode argument can only be 'left' or 'right' but not ''rTr6Frz5Array shapes are not compatible for Q @ c operation: z vs rz5Array shapes are not compatible for c @ Q operation: Nr)Zormqr)sdTCF)r"orderr0r2LZ C_CONTIGUOUSz gormqr/gunmqr) overwrite_cr5)rr r#ndimZ atleast_2dr:r$r&minrrtypecodeZzerosr"flagsrZravel)r*cr+r, conjugaterr?Zonedimr/r0rr3r1Z gor_un_mqrZtranscclrZcQrrrrsL             rcCsd|dvrtd|r t|}n t|}t|jdkr@td|j\}}|pVt||}td|f\}t|d|||d\} } |dkr||krt | ||} nt | | d | d f} |d kr| Std | f\} ||krt| d | | d | |d d\} nZ|dkr$t| d | | |d d\} n8tj ||f| j d}| || d <t| d || |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']rzexpected matrix)gerqfrHr rNr)Zorgrqz gorgrq/gungrqrr!) rr r#r$r%r&rrrr'r)r")r*rrr+r-r.r/r0rHrr1r2Z gor_un_grqr3Zrq1rrrrGsFA           r)FNrFT)r5FFFF)FNrT) __doc__r ZlapackrZ_miscr__all__rrrrrrrrs