code: def lu_factor(a, 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, M) array_like
          Matrix to decompose
      overwrite_a : bool, optional
          Whether to overwrite data in A (may increase 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
      -------
      lu : (N, N) ndarray
          Matrix containing U in its upper triangle, and L in its lower triangle.
          The unit diagonal elements of L are not stored.
      piv : (N,) ndarray
          Pivot indices representing the permutation matrix P:
          row i of matrix was interchanged with row piv[i].
  
      See also
      --------
      lu_solve : solve an equation system using the LU factorization of a matrix
  
      Notes
      -----
      This is a wrapper to the ``*GETRF`` routines from LAPACK.
  
      Examples
      --------
      >>> from scipy.linalg import lu_factor
      >>> A = np.array([[2, 5, 8, 7], [5, 2, 2, 8], [7, 5, 6, 6], [5, 4, 4, 8]])
      >>> lu, piv = lu_factor(A)
      >>> piv
      array([2, 2, 3, 3], dtype=int32)
  
      Convert LAPACK's ``piv`` array to NumPy index and test the permutation
  
      >>> piv_py = [2, 0, 3, 1]
      >>> L, U = np.tril(lu, k=-1) + np.eye(4), np.triu(lu)
      >>> np.allclose(A[piv_py] - L @ U, np.zeros((4, 4)))
      True
      """
      if check_finite:
          a1 = asarray_chkfinite(a)
      else:
          a1 = asarray(a)
      if len(a1.shape) != 2 or (a1.shape[0] != a1.shape[1]):
          raise ValueError("expected square matrix")
      overwrite_a = overwrite_a or (_datacopied(a1, a))
      (getrf,) = get_lapack_funcs(("getrf",), (a1,))
      lu, piv, info = getrf(a1, overwrite_a=overwrite_a)
      if info < 0:
          raise ValueError(
              "illegal value in %dth argument of "
              "internal getrf (lu_factor)" % -info
          )
      if info > 0:
          warn(
              "Diagonal number %d is exactly zero. Singular matrix."
              % info,
              LinAlgWarning,
              stacklevel=2,
          )
      return lu, piv
  
file_path: catboost/contrib/python/scipy/py3/scipy/linalg/decomp_lu.py
imports: 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 1 for calling a global function with example usage: lu_factor(a, overwrite_a, check_finite) and returns: lu,  piv