code: def lu(a, permute_l=False, overwrite_a=False, check_finite=True):
      """
      Compute pivoted LU decomposition of a matrix.
  
      The decomposition is::
  
          A = P L U
  
      where P is a permutation matrix, L lower triangular with unit
      diagonal elements, and U upper triangular.
  
      Parameters
      ----------
      a : (M, N) array_like
          Array to decompose
      permute_l : bool, optional
          Perform the multiplication P*L  (Default: do not permute)
      overwrite_a : bool, optional
          Whether to overwrite data in a (may improve performance)
      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
      -------
      **(If permute_l == False)**
  
      p : (M, M) ndarray
          Permutation matrix
      l : (M, K) ndarray
          Lower triangular or trapezoidal matrix with unit diagonal.
          K = min(M, N)
      u : (K, N) ndarray
          Upper triangular or trapezoidal matrix
  
      **(If permute_l == True)**
  
      pl : (M, K) ndarray
          Permuted L matrix.
          K = min(M, N)
      u : (K, N) ndarray
          Upper triangular or trapezoidal matrix
  
      Notes
      -----
      This is a LU factorization routine written for Scipy.
  
      Examples
      --------
      >>> from scipy.linalg import lu
      >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
      >>> p, l, u = lu(A)
      >>> np.allclose(A - p @ l @ u, np.zeros((4, 4)))
      True
  
      """
      if check_finite:
          a1 = asarray_chkfinite(a)
      else:
          a1 = asarray(a)
      if len(a1.shape) != 2:
          raise ValueError("expected matrix")
      overwrite_a = overwrite_a or (_datacopied(a1, a))
      (flu,) = get_flinalg_funcs(("lu",), (a1,))
      p, l, u, info = flu(
          a1, permute_l=permute_l, overwrite_a=overwrite_a
      )
      if info < 0:
          raise ValueError(
              "illegal value in %d-th argument of "
              "internal lu.getrf" % -info
          )
      if permute_l:
          return l, u
      return p, l, u
  
file_path: catboost/contrib/python/scipy/py2/scipy/linalg/decomp_lu.py
imports: from __future__ import division, print_function, absolute_import
  from warnings import warn
  from numpy import asarray, asarray_chkfinite
  from .misc import _datacopied, LinAlgWarning
  from .lapack import get_lapack_funcs
  from .flinalg import get_flinalg_funcs
label_desc: Use image node_id 3 for calling a global function with example usage: lu(a, permute_l, overwrite_a, check_finite) and returns: p,  l,  u, l,  u