parameters: (a, overwrite_a=False, lwork=None, mode='full', pivoting=False,
         check_finite=True)
return_statement: return (Q,) + Rj
docstring: 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)
      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
      --------
      >>> from scipy import random, linalg, dot, diag, all, allclose
      >>> a = random.randn(9, 6)
  
      >>> q, r = linalg.qr(a)
      >>> allclose(a, np.dot(q, r))
      True
      >>> q.shape, r.shape
      ((9, 9), (9, 6))
  
      >>> r2 = linalg.qr(a, mode='r')
      >>> 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 = abs(diag(r4))
      >>> all(d[1:] <= d[:-1])
      True
      >>> allclose(a[:, p4], 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,))
docstring_summary: Compute QR decomposition of a matrix.
docstring_tokens: Compute QR decomposition of a matrix .
function: def qr(a, overwrite_a=False, lwork=None, mode='full', pivoting=False,
         check_finite=True):
      """
      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)
      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
      --------
      >>> from scipy import random, linalg, dot, diag, all, allclose
      >>> a = random.randn(9, 6)
  
      >>> q, r = linalg.qr(a)
      >>> allclose(a, np.dot(q, r))
      True
      >>> q.shape, r.shape
      ((9, 9), (9, 6))
  
      >>> r2 = linalg.qr(a, mode='r')
      >>> 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 = abs(diag(r4))
      >>> all(d[1:] <= d[:-1])
      True
      >>> allclose(a[:, p4], 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,))
  
      """
      # 'qr' was the old default, equivalent to 'full'. Neither 'full' nor
      # 'qr' are used below.
      # 'raw' is used internally by qr_multiply
      if mode not in ['full', 'qr', 'r', 'economic', 'raw']:
          raise ValueError("Mode argument should be one of ['full', 'r',"
                           "'economic', 'raw']")
  
      if check_finite:
          a1 = numpy.asarray_chkfinite(a)
      else:
          a1 = numpy.asarray(a)
      if len(a1.shape) != 2:
          raise ValueError("expected 2D array")
      M, N = a1.shape
      overwrite_a = overwrite_a or (_datacopied(a1, a))
  
      if pivoting:
          geqp3, = get_lapack_funcs(('geqp3',), (a1,))
          qr, jpvt, tau = safecall(geqp3, "geqp3", a1, overwrite_a=overwrite_a)
          jpvt -= 1  # geqp3 returns a 1-based index array, so subtract 1
      else:
          geqrf, = get_lapack_funcs(('geqrf',), (a1,))
          qr, tau = safecall(geqrf, "geqrf", a1, lwork=lwork,
                             overwrite_a=overwrite_a)
  
      if mode not in ['economic', 'raw'] or M < N:
          R = numpy.triu(qr)
      else:
          R = numpy.triu(qr[:N, :])
  
      if pivoting:
          Rj = R, jpvt
      else:
          Rj = R,
  
      if mode == 'r':
          return Rj
      elif mode == 'raw':
          return ((qr, tau),) + Rj
  
      gor_un_gqr, = get_lapack_funcs(('orgqr',), (qr,))
  
      if M < N:
          Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr[:, :M], tau,
                        lwork=lwork, overwrite_a=1)
      elif mode == 'economic':
          Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qr, tau, lwork=lwork,
                        overwrite_a=1)
      else:
          t = qr.dtype.char
          qqr = numpy.empty((M, M), dtype=t)
          qqr[:, :N] = qr
          Q, = safecall(gor_un_gqr, "gorgqr/gungqr", qqr, tau, lwork=lwork,
                        overwrite_a=1)
  
      return (Q,) + Rj
function_tokens: def qr ( a , overwrite_a = False , lwork = None , mode = 'full' , pivoting = False , check_finite = True ) : # 'qr' was the old default, equivalent to 'full'. Neither 'full' nor # 'qr' are used below. # 'raw' is used internally by qr_multiply if mode not in [ 'full' , 'qr' , 'r' , 'economic' , 'raw' ] : raise ValueError ( "Mode argument should be one of ['full', 'r'," "'economic', 'raw']" ) if check_finite : a1 = numpy . asarray_chkfinite ( a ) else : a1 = numpy . asarray ( a ) if len ( a1 . shape ) != 2 : raise ValueError ( "expected 2D array" ) M , N = a1 . shape overwrite_a = overwrite_a or ( _datacopied ( a1 , a ) ) if pivoting : geqp3 , = get_lapack_funcs ( ( 'geqp3' , ) , ( a1 , ) ) qr , jpvt , tau = safecall ( geqp3 , "geqp3" , a1 , overwrite_a = overwrite_a ) jpvt -= 1 # geqp3 returns a 1-based index array, so subtract 1 else : geqrf , = get_lapack_funcs ( ( 'geqrf' , ) , ( a1 , ) ) qr , tau = safecall ( geqrf , "geqrf" , a1 , lwork = lwork , overwrite_a = overwrite_a ) if mode not in [ 'economic' , 'raw' ] or M < N : R = numpy . triu ( qr ) else : R = numpy . triu ( qr [ : N , : ] ) if pivoting : Rj = R , jpvt else : Rj = R , if mode == 'r' : return Rj elif mode == 'raw' : return ( ( qr , tau ) , ) + Rj gor_un_gqr , = get_lapack_funcs ( ( 'orgqr' , ) , ( qr , ) ) if M < N : Q , = safecall ( gor_un_gqr , "gorgqr/gungqr" , qr [ : , : M ] , tau , lwork = lwork , overwrite_a = 1 ) elif mode == 'economic' : Q , = safecall ( gor_un_gqr , "gorgqr/gungqr" , qr , tau , lwork = lwork , overwrite_a = 1 ) else : t = qr . dtype . char qqr = numpy . empty ( ( M , M ) , dtype = t ) qqr [ : , : N ] = qr Q , = safecall ( gor_un_gqr , "gorgqr/gungqr" , qqr , tau , lwork = lwork , overwrite_a = 1 ) return ( Q , ) + Rj