code: 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
  
file_path: catboost/contrib/python/scipy/py2/scipy/linalg/decomp_qr.py
imports: from __future__ import division, print_function, absolute_import
  import numpy
  from .lapack import get_lapack_funcs
  from .misc import _datacopied
label_desc: Use image node_id 2 for calling a global function with example usage: qr(a, overwrite_a, lwork, mode, pivoting, check_finite) and returns: unknown, Rj, unknown