code: def pinvh(
      a,
      atol=None,
      rtol=None,
      lower=True,
      return_rank=False,
      check_finite=True,
      cond=None,
      rcond=None,
  ):
      """
      Compute the (Moore-Penrose) pseudo-inverse of a Hermitian matrix.
  
      Calculate a generalized inverse of a copmlex Hermitian/real symmetric
      matrix using its eigenvalue decomposition and including all eigenvalues
      with 'large' absolute value.
  
      Parameters
      ----------
      a : (N, N) array_like
          Real symmetric or complex hermetian 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 ``N * eps`` where
          ``eps`` is the machine precision value of the datatype of ``a``.
  
          .. versionadded:: 1.7.0
  
      lower : bool, optional
          Whether the pertinent array data is taken from the lower or upper
          triangle of `a`. (Default: lower)
      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, N) ndarray
          The pseudo-inverse of matrix `a`.
      rank : int
          The effective rank of the matrix.  Returned if `return_rank` is True.
  
      Raises
      ------
      LinAlgError
          If eigenvalue algorithm does not converge.
  
      Examples
      --------
      >>> from scipy.linalg import pinvh
      >>> rng = np.random.default_rng()
      >>> a = rng.standard_normal((9, 6))
      >>> a = np.dot(a, a.T)
      >>> B = pinvh(a)
      >>> np.allclose(a, a @ B @ a)
      True
      >>> np.allclose(B, B @ a @ B)
      True
  
      """
      a = _asarray_validated(a, check_finite=check_finite)
      s, u = decomp.eigh(a, lower=lower, check_finite=False)
      t = u.dtype.char.lower()
      maxS = np.max(np.abs(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
      above_cutoff = abs(s) > val
  
      psigma_diag = 1.0 / s[above_cutoff]
      u = u[:, above_cutoff]
  
      B = (u * psigma_diag) @ u.conj().T
  
      if return_rank:
          return B, len(psigma_diag)
      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 14 for calling a global function with example usage: pinvh(a, atol, rtol, lower, return_rank, check_finite, cond, rcond) and returns: B,  len, B