docs: def eigenvalues_auto(mat, n_eivals='auto'):
      """
      Automatically computes the spectrum of a given Laplacian matrix.
      
      Parameters
      ----------
      mat : numpy.ndarray or scipy.sparse
          Laplacian matrix
      n_eivals : string or int or tuple
          Number of eigenvalues to compute / use for approximation.
          If string, we expect either 'full' or 'auto', otherwise error will be raised. 'auto' lets the program decide based on the faithful usage. 'full' computes all eigenvalues.
          If int, compute n_eivals eigenvalues from each side and approximate using linear growth approximation.
          If tuple, we expect two ints, first for lower part of approximation, and second for the upper part.
  
      Returns
      -------
      np.ndarray
          Vector of approximated eigenvalues
  
      Examples
      --------
      >>> eigenvalues_auto(numpy.array([[ 2, -1, -1], [-1,  2, -1], [-1, -1,  2]]), 'auto')
      array([0, 3, 3])
  
      """
      do_full = True
      n_lower = 150
      n_upper = 150
      nv = mat.shape[0]
      if n_eivals == 'auto':
          if mat.shape[0] > 1024:
              do_full = False
      if n_eivals == 'full':
          do_full = True
      if isinstance(n_eivals, int):
          n_lower = n_upper = n_eivals
          do_full = False
      if isinstance(n_eivals, tuple):
          n_lower, n_upper = n_eivals
          do_full = False
      if do_full and sps.issparse(mat):
          mat = mat.todense()
      if sps.issparse(mat):
          if n_lower == n_upper:
              tr_eivals = spsl.eigsh(mat, 2*n_lower, which='BE', return_eigenvectors=False)
              return updown_linear_approx(tr_eivals[:n_upper], tr_eivals[n_upper:], nv)
          else:
              lo_eivals = spsl.eigsh(mat, n_lower, which='SM', return_eigenvectors=False)[::-1]
              up_eivals = spsl.eigsh(mat, n_upper, which='LM', return_eigenvectors=False)
              return updown_linear_approx(lo_eivals, up_eivals, nv)
      else:
          if do_full:
              return spl.eigvalsh(mat)
          else:
              lo_eivals = spl.eigvalsh(mat, eigvals=(0, n_lower-1))
              up_eivals = spl.eigvalsh(mat, eigvals=(nv-n_upper-1, nv-1))
              return updown_linear_approx(lo_eivals, up_eivals, nv)