code: def eigvalsh(
      a,
      b=None,
      *,
      lower=True,
      overwrite_a=False,
      overwrite_b=False,
      turbo=_NoValue,
      eigvals=_NoValue,
      type=1,
      check_finite=True,
      subset_by_index=None,
      subset_by_value=None,
      driver=None,
  ):
      """
      Solves a standard or generalized eigenvalue problem for a complex
      Hermitian or real symmetric matrix.
  
      Find eigenvalues array ``w`` of array ``a``, where ``b`` is positive
      definite such that for every eigenvalue λ (i-th entry of w) and its
      eigenvector vi (i-th column of v) satisfies::
  
                        a @ vi = λ * b @ vi
          vi.conj().T @ a @ vi = λ
          vi.conj().T @ b @ vi = 1
  
      In the standard problem, b is assumed to be the identity matrix.
  
      Parameters
      ----------
      a : (M, M) array_like
          A complex Hermitian or real symmetric matrix whose eigenvalues will
          be computed.
      b : (M, M) array_like, optional
          A complex Hermitian or real symmetric definite positive matrix in.
          If omitted, identity matrix is assumed.
      lower : bool, optional
          Whether the pertinent array data is taken from the lower or upper
          triangle of ``a`` and, if applicable, ``b``. (Default: lower)
      overwrite_a : bool, optional
          Whether to overwrite data in ``a`` (may improve performance). Default
          is False.
      overwrite_b : bool, optional
          Whether to overwrite data in ``b`` (may improve performance). Default
          is False.
      type : int, optional
          For the generalized problems, this keyword specifies the problem type
          to be solved for ``w`` and ``v`` (only takes 1, 2, 3 as possible
          inputs)::
  
              1 =>     a @ v = w @ b @ v
              2 => a @ b @ v = w @ v
              3 => b @ a @ v = w @ v
  
          This keyword is ignored for standard problems.
      check_finite : bool, optional
          Whether to check that the input matrices contain 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.
      subset_by_index : iterable, optional
          If provided, this two-element iterable defines the start and the end
          indices of the desired eigenvalues (ascending order and 0-indexed).
          To return only the second smallest to fifth smallest eigenvalues,
          ``[1, 4]`` is used. ``[n-3, n-1]`` returns the largest three. Only
          available with "evr", "evx", and "gvx" drivers. The entries are
          directly converted to integers via ``int()``.
      subset_by_value : iterable, optional
          If provided, this two-element iterable defines the half-open interval
          ``(a, b]`` that, if any, only the eigenvalues between these values
          are returned. Only available with "evr", "evx", and "gvx" drivers. Use
          ``np.inf`` for the unconstrained ends.
      driver : str, optional
          Defines which LAPACK driver should be used. Valid options are "ev",
          "evd", "evr", "evx" for standard problems and "gv", "gvd", "gvx" for
          generalized (where b is not None) problems. See the Notes section of
          `scipy.linalg.eigh`.
      turbo : bool, optional, deprecated
          .. deprecated:: 1.5.0
              'eigvalsh' keyword argument `turbo` is deprecated in favor of
              ``driver=gvd`` option and will be removed in SciPy 1.14.0.
  
      eigvals : tuple (lo, hi), optional
          .. deprecated:: 1.5.0
              'eigvalsh' keyword argument `eigvals` is deprecated in favor of
              `subset_by_index` option and will be removed in SciPy 1.14.0.
  
      Returns
      -------
      w : (N,) ndarray
          The N (N<=M) selected eigenvalues, in ascending order, each
          repeated according to its multiplicity.
  
      Raises
      ------
      LinAlgError
          If eigenvalue computation does not converge, an error occurred, or
          b matrix is not definite positive. Note that if input matrices are
          not symmetric or Hermitian, no error will be reported but results will
          be wrong.
  
      See Also
      --------
      eigh : eigenvalues and right eigenvectors for symmetric/Hermitian arrays
      eigvals : eigenvalues of general arrays
      eigvals_banded : eigenvalues for symmetric/Hermitian band matrices
      eigvalsh_tridiagonal : eigenvalues of symmetric/Hermitian tridiagonal
          matrices
  
      Notes
      -----
      This function does not check the input array for being Hermitian/symmetric
      in order to allow for representing arrays with only their upper/lower
      triangular parts.
  
      This function serves as a one-liner shorthand for `scipy.linalg.eigh` with
      the option ``eigvals_only=True`` to get the eigenvalues and not the
      eigenvectors. Here it is kept as a legacy convenience. It might be
      beneficial to use the main function to have full control and to be a bit
      more pythonic.
  
      Examples
      --------
      For more examples see `scipy.linalg.eigh`.
  
      >>> import numpy as np
      >>> from scipy.linalg import eigvalsh
      >>> A = np.array([[6, 3, 1, 5], [3, 0, 5, 1], [1, 5, 6, 2], [5, 1, 2, 2]])
      >>> w = eigvalsh(A)
      >>> w
      array([-3.74637491, -0.76263923,  6.08502336, 12.42399079])
  
      """
      return eigh(
          a,
          b=b,
          lower=lower,
          eigvals_only=True,
          overwrite_a=overwrite_a,
          overwrite_b=overwrite_b,
          turbo=turbo,
          eigvals=eigvals,
          type=type,
          check_finite=check_finite,
          subset_by_index=subset_by_index,
          subset_by_value=subset_by_value,
          driver=driver,
      )
  
imports: import warnings
  import numpy
  from numpy import array, isfinite, inexact, nonzero, iscomplexobj, flatnonzero, conj, asarray, argsort, empty, iscomplex, zeros, einsum, eye, inf
  from scipy._lib._util import _asarray_validated
  from ._misc import LinAlgError, _datacopied, norm
  from .lapack import get_lapack_funcs, _compute_lwork
  from scipy._lib.deprecation import _NoValue, _deprecate_positional_args
label_desc: Use image node_id 9 for calling a global function with example usage: eigvalsh(a, b) and returns: eigh