@abstractmethod
def amplitudes_to_vector(self, amplitudes: Namespace[SpinArrayType]) -> NDArray[T]:
    """Construct a vector containing all of the amplitudes used in the given ansatz.

    Args:
        amplitudes: Cluster amplitudes.

    Returns:
        Cluster amplitudes as a vector.
    """
    pass

@abstractmethod
def vector_to_amplitudes(self, vector: NDArray[T]) -> Namespace[SpinArrayType]:
    """Construct amplitudes from a vector.

    Args:
        vector: Cluster amplitudes as a vector.

    Returns:
        Cluster amplitudes.
    """
    pass

@abstractmethod
def matvec(
    self,
    vector: NDArray[T],
    eris: Optional[ERIsInputType] = None,
    ints: Optional[Namespace[NDArray[T]]] = None,
    left: bool = False,
) -> NDArray[T]:
    """Apply the Hamiltonian to a vector.

    Args:
        vector: State vector to apply the Hamiltonian to.
        eris: Electronic repulsion integrals.
        ints: Intermediate products.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Resulting vector.
    """
    pass

@abstractmethod
def matvec_intermediates(
    self, eris: Optional[ERIsInputType] = None, left: bool = False
) -> Namespace[NDArray[T]]:
    """Get the intermediates for application of the Hamiltonian to a vector.

    Args:
        eris: Electronic repulsion integrals.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Intermediate products.
    """
    pass

@abstractmethod
def diag(self, eris: Optional[ERIsInputType] = None) -> NDArray[T]:
    """Get the diagonal of the Hamiltonian.

    Args:
        eris: Electronic repulsion integrals.

    Returns:
        Diagonal of the Hamiltonian.
    """
    pass

def get_pick(
    self, guesses: Optional[NDArray[T]] = None, real_system: bool = True
) -> PickFunctionType:
    """Get the function to pick the eigenvalues matching the criteria.

    Args:
        guesses: Initial guesses for the roots.
        real_system: Whether the system is real-valued.

    Returns:
        Function to pick the eigenvalues.
    """

    if self.options.koopmans:
        assert guesses is not None

        def pick(
            w: NDArray[T], v: NDArray[T], nroots: int, env: dict[str, Any]
        ) -> tuple[NDArray[T], NDArray[T], int]:
            """Pick the eigenvalues."""
            x0 = np.asarray(lib.linalg_helper._gen_x0(env["v"], env["xs"]))
            s = guesses.conj() @ x0.T
            s = util.einsum("pi,pi->i", s.conj(), s)
            arg = np.argsort(-s)[:nroots]
            return lib.linalg_helper._eigs_cmplx2real(w, v, arg, real_system)  # type: ignore

    else:

        def pick(
            w: NDArray[T], v: NDArray[T], nroots: int, env: dict[str, Any]
        ) -> tuple[NDArray[T], NDArray[T], int]:
            """Pick the eigenvalues."""
            real_idx = np.where(abs(w.imag) < 1e-3)[0]
            w, v, idx = lib.linalg_helper._eigs_cmplx2real(w, v, real_idx, real_system)
            return w, v, idx

    return pick

def get_guesses(self, diag: Optional[NDArray[T]] = None) -> list[NDArray[T]]:
    """Get the initial guesses vectors.

    Args:
        diag: Diagonal of the Hamiltonian.

    Returns:
        Initial guesses.
    """
    if diag is None:
        diag = self.diag()
    arg = self._argsort_guesses(diag)

    nroots = min(self.options.nroots, diag.size)
    guesses: list[NDArray[T]] = []
    for root, guess in enumerate(arg[:nroots]):
        g: NDArray[T] = np.zeros(diag.shape, dtype=types[float])
        g[guess] = 1.0
        guesses.append(g)

    return guesses

def callback(self, envs: dict[str, Any]) -> None:  # noqa: B027
    """Callback function for the eigensolver."""  # noqa: D401
    pass

def davidson(
    self,
    eris: Optional[ERIsInputType] = None,
    guesses: Optional[list[NDArray[T]]] = None,
) -> NDArray[T]:
    """Solve the EOM Hamiltonian using the Davidson solver.

    Args:
        eris: Electronic repulsion integrals.
        guesses: Initial guesses for the roots.

    Returns:
        Energies of the roots.
    """
    timer = util.Timer()

    # Get the ERIs:
    eris = self.ebcc.get_eris(eris)

    self.log.output(
        "Solving for %s excitations using the Davidson solver.", self.excitation_type.upper()
    )

    # Get the matrix-vector products and the diagonal:
    ints = self.matvec_intermediates(eris=eris, left=self.options.left)
    matvecs = lambda vs: [
        self.matvec(v, eris=eris, ints=ints, left=self.options.left) for v in vs
    ]
    diag = self.diag(eris=eris)

    # Get the guesses:
    if guesses is None:
        guesses = self.get_guesses(diag=diag)

    # Solve the EOM Hamiltonian:
    nroots = min(len(guesses), self.options.nroots)
    pick = self.get_pick(guesses=np.stack(guesses))
    converged, e, v = lib.davidson_nosym1(
        matvecs,
        guesses,
        diag,
        tol=self.options.e_tol,
        nroots=nroots,
        pick=pick,
        max_cycle=self.options.max_iter,
        max_space=self.options.max_space,
        callback=self.callback,
        verbose=0,
    )

    # Check for convergence:
    if all(converged):
        self.log.debug("")
        self.log.output(f"{ANSI.g}Converged.{ANSI.R}")
    else:
        self.log.debug("")
        self.log.warning(
            f"{ANSI.r}Failed to converge {sum(not c for c in converged)} roots.{ANSI.R}"
        )

    # Update attributes:
    self.converged = converged
    self.e = e.astype(types[float])
    self.v = np.asarray(v).T.astype(types[float])

    self.log.debug("")
    self.log.output(
        f"{ANSI.B}{'Root':>4s} {'Energy':>16s} {'Weight':>13s} {'Conv.':>8s}{ANSI.R}"
    )
    for n, (en, vn, cn) in enumerate(zip(self.e, self.v.T, converged)):
        r1n = self.vector_to_amplitudes(vn)["r1"]
        qpwt = self._quasiparticle_weight(r1n)
        self.log.output(
            f"{n:>4d} {en.item():>16.10f} {qpwt:>13.5g} "
            f"{[ANSI.r, ANSI.g][bool(cn)]}{cn!r:>8s}{ANSI.R}"
        )

    self.log.debug("")
    self.log.debug("Time elapsed: %s", timer.format_time(timer()))
    self.log.debug("")

    return self.e

def matvec(
    self,
    vector: NDArray[T],
    eris: Optional[ERIsInputType] = None,
    ints: Optional[Namespace[NDArray[T]]] = None,
    left: bool = False,
) -> NDArray[T]:
    """Apply the Hamiltonian to a vector.

    Args:
        vector: State vector to apply the Hamiltonian to.
        eris: Electronic repulsion integrals.
        ints: Intermediate products.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Resulting vector.
    """
    if not ints:
        ints = self.matvec_intermediates(eris=eris, left=left)
    amplitudes = self.vector_to_amplitudes(vector)
    func, kwargs = self.ebcc._load_function(
        f"hbar_{'l' if left else ''}matvec_ip",
        eris=eris,
        ints=ints,
        amplitudes=self.ebcc.amplitudes,
        excitations=amplitudes,
    )
    res: Namespace[SpinArrayType] = func(**kwargs)
    res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()})
    return self.amplitudes_to_vector(res)

def matvec_intermediates(
    self, eris: Optional[ERIsInputType] = None, left: bool = False
) -> Namespace[NDArray[T]]:
    """Get the intermediates for application of the Hamiltonian to a vector.

    Args:
        eris: Electronic repulsion integrals.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Intermediate products.
    """
    func, kwargs = self.ebcc._load_function(
        f"hbar_{'l' if left else ''}matvec_ip_intermediates",
        eris=eris,
        amplitudes=self.ebcc.amplitudes,
    )
    res: Namespace[NDArray[T]] = util.Namespace(**func(**kwargs))
    return res

def matvec(
    self,
    vector: NDArray[T],
    eris: Optional[ERIsInputType] = None,
    ints: Optional[Namespace[NDArray[T]]] = None,
    left: bool = False,
) -> NDArray[T]:
    """Apply the Hamiltonian to a vector.

    Args:
        vector: State vector to apply the Hamiltonian to.
        eris: Electronic repulsion integrals.
        ints: Intermediate products.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Resulting vector.
    """
    if not ints:
        ints = self.matvec_intermediates(eris=eris, left=left)
    amplitudes = self.vector_to_amplitudes(vector)
    func, kwargs = self.ebcc._load_function(
        f"hbar_{'l' if left else ''}matvec_ea",
        eris=eris,
        ints=ints,
        amplitudes=self.ebcc.amplitudes,
        excitations=amplitudes,
    )
    res: Namespace[SpinArrayType] = func(**kwargs)
    res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()})
    return self.amplitudes_to_vector(res)

def matvec_intermediates(
    self, eris: Optional[ERIsInputType] = None, left: bool = False
) -> Namespace[NDArray[T]]:
    """Get the intermediates for application of the Hamiltonian to a vector.

    Args:
        eris: Electronic repulsion integrals.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Intermediate products.
    """
    func, kwargs = self.ebcc._load_function(
        f"hbar_{'l' if left else ''}matvec_ea_intermediates",
        eris=eris,
        amplitudes=self.ebcc.amplitudes,
    )
    res: Namespace[NDArray[T]] = util.Namespace(**func(**kwargs))
    return res

def matvec(
    self,
    vector: NDArray[T],
    eris: Optional[ERIsInputType] = None,
    ints: Optional[Namespace[NDArray[T]]] = None,
    left: bool = False,
) -> NDArray[T]:
    """Apply the Hamiltonian to a vector.

    Args:
        vector: State vector to apply the Hamiltonian to.
        eris: Electronic repulsion integrals.
        ints: Intermediate products.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Resulting vector.
    """
    if not ints:
        ints = self.matvec_intermediates(eris=eris, left=left)
    amplitudes = self.vector_to_amplitudes(vector)
    func, kwargs = self.ebcc._load_function(
        f"hbar_{'l' if left else ''}matvec_ee",
        eris=eris,
        ints=ints,
        amplitudes=self.ebcc.amplitudes,
        excitations=amplitudes,
    )
    res: Namespace[SpinArrayType] = func(**kwargs)
    res = util.Namespace(**{key.rstrip("new"): val for key, val in res.items()})
    return self.amplitudes_to_vector(res)

def matvec_intermediates(
    self, eris: Optional[ERIsInputType] = None, left: bool = False
) -> Namespace[NDArray[T]]:
    """Get the intermediates for application of the Hamiltonian to a vector.

    Args:
        eris: Electronic repulsion integrals.
        left: Whether to apply the left-hand side of the Hamiltonian.

    Returns:
        Intermediate products.
    """
    func, kwargs = self.ebcc._load_function(
        f"hbar_{'l' if left else ''}matvec_ee_intermediates",
        eris=eris,
        amplitudes=self.ebcc.amplitudes,
    )
    res: Namespace[NDArray[T]] = util.Namespace(**func(**kwargs))
    return res