code: def pinv(
      a,
      atol=None,
      rtol=None,
      return_rank=False,
      check_finite=True,
      cond=None,
      rcond=None,
  ):
      """
      Compute the (Moore-Penrose) pseudo-inverse of a matrix.
  
      Calculate a generalized inverse of a matrix using its
      singular-value decomposition ``U @ S @ V`` in the economy mode and picking
      up only the columns/rows that are associated with significant singular
      values.
  
      If ``s`` is the maximum singular value of ``a``, then the
      significance cut-off value is determined by ``atol + rtol * s``. Any
      singular value below this value is assumed insignificant.
  
      Parameters
      ----------
      a : (M, N) array_like
          Matrix to be pseudo-inverted.
      atol: float, optional
          Absolute threshold term, default value is 0.
  
          .. versionadded:: 1.7.0
  
      rtol: float, optional
          Relative threshold term, default value is ``max(M, N) * eps`` where
          ``eps`` is the machine precision value of the datatype of ``a``.
  
          .. versionadded:: 1.7.0
  
      return_rank : bool, optional
          If True, return the effective rank of the matrix.
      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.
      cond, rcond : float, optional
          In older versions, these values were meant to be used as ``atol`` with
          ``rtol=0``. If both were given ``rcond`` overwrote ``cond`` and hence
          the code was not correct. Thus using these are strongly discouraged and
          the tolerances above are recommended instead. In fact, if provided,
          atol, rtol takes precedence over these keywords.
  
          .. versionchanged:: 1.7.0
              Deprecated in favor of ``rtol`` and ``atol`` parameters above and
              will be removed in future versions of SciPy.
  
          .. versionchanged:: 1.3.0
              Previously the default cutoff value was just ``eps*f`` where ``f``
              was ``1e3`` for single precision and ``1e6`` for double precision.
  
      Returns
      -------
      B : (N, M) ndarray
          The pseudo-inverse of matrix `a`.
      rank : int
          The effective rank of the matrix. Returned if `return_rank` is True.
  
      Raises
      ------
      LinAlgError
          If SVD computation does not converge.
  
      Examples
      --------
      >>> from scipy import linalg
      >>> rng = np.random.default_rng()
      >>> a = rng.standard_normal((9, 6))
      >>> B = linalg.pinv(a)
      >>> np.allclose(a, a @ B @ a)
      True
      >>> np.allclose(B, B @ a @ B)
      True
  
      """
      a = _asarray_validated(a, check_finite=check_finite)
      u, s, vh = decomp_svd.svd(
          a, full_matrices=False, check_finite=False
      )
      t = u.dtype.char.lower()
      maxS = np.max(s)
  
      if rcond or cond:
          warn(
              'Use of the "cond" and "rcond" keywords are deprecated and '
              'will be removed in future versions of SciPy. Use "atol" and '
              '"rtol" keywords instead',
              DeprecationWarning,
              stacklevel=2,
          )
  
      # backwards compatible only atol and rtol are both missing
      if (rcond or cond) and (atol is None) and (rtol is None):
          atol = rcond or cond
          rtol = 0.0
  
      atol = 0.0 if atol is None else atol
      rtol = max(a.shape) * np.finfo(t).eps if (rtol is None) else rtol
  
      if (atol < 0.0) or (rtol < 0.0):
          raise ValueError("atol and rtol values must be positive.")
  
      val = atol + maxS * rtol
      rank = np.sum(s > val)
  
      u = u[:, :rank]
      u /= s[:rank]
      B = (u @ vh[:rank]).conj().T
  
      if return_rank:
          return B, rank
      else:
          return B
  
imports: from warnings import warn
  import numpy
  from numpy import atleast_1d, atleast_2d
  from .flinalg import get_flinalg_funcs
  from .lapack import get_lapack_funcs, _compute_lwork
  from .misc import LinAlgError, _datacopied, LinAlgWarning
  from .decomp import _asarray_validated
  from .None import decomp, decomp_svd
  from ._solve_toeplitz import levinson
label_desc: Use image node_id 12 for calling a global function with example usage: pinv(a, atol, rtol, return_rank, check_finite, cond, rcond) and returns: B,  rank, B