Line data    Source code

       1             : // SPDX-FileCopyrightText: 2024 Pairinteraction Developers
       2             : // SPDX-License-Identifier: LGPL-3.0-or-later
       3             : 
       4             : #include "./DiagonalizerInterface.py.hpp"
       5             : 
       6             : #include "pairinteraction/interfaces/DiagonalizerInterface.hpp"
       7             : 
       8             : #include <nanobind/eigen/sparse.h>
       9             : #include <nanobind/nanobind.h>
      10             : #include <nanobind/stl/complex.h>
      11             : #include <nanobind/stl/optional.h>
      12             : 
      13             : namespace nb = nanobind;
      14             : using namespace pairinteraction;
      15             : 
      16             : template <typename T>
      17           2 : static void declare_diagonalizer_interface(nb::module_ &m, std::string const &type_name) {
      18           2 :     std::string pylass_name = "DiagonalizerInterface" + type_name;
      19             :     using real_t = typename DiagonalizerInterface<T>::real_t;
      20           2 :     nb::class_<DiagonalizerInterface<T>> pyclass(m, pylass_name.c_str());
      21             :     pyclass
      22           2 :         .def("eigh",
      23           2 :              nb::overload_cast<const Eigen::SparseMatrix<T, Eigen::RowMajor> &, double>(
      24             :                  &DiagonalizerInterface<T>::eigh, nb::const_))
      25             :         .def("eigh",
      26             :              nb::overload_cast<const Eigen::SparseMatrix<T, Eigen::RowMajor> &,
      27           2 :                                std::optional<real_t>, std::optional<real_t>, double>(
      28             :                  &DiagonalizerInterface<T>::eigh, nb::const_));
      29           2 : }
      30             : 
      31             : template <typename T>
      32           2 : static void declare_eigen_system_h(nb::module_ &m, std::string const &type_name) {
      33           2 :     std::string pylass_name = "EigenSystemH" + type_name;
      34           4 :     nb::class_<EigenSystemH<T>> pyclass(m, pylass_name.c_str());
      35           2 :     pyclass.def_rw("eigenvectors", &EigenSystemH<T>::eigenvectors)
      36             :         .def_rw("eigenvalues", &EigenSystemH<T>::eigenvalues);
      37           2 : }
      38             : 
      39           1 : void bind_diagonalizer_interface(nb::module_ &m) {
      40           1 :     declare_diagonalizer_interface<double>(m, "Real");
      41           1 :     declare_diagonalizer_interface<std::complex<double>>(m, "Complex");
      42           1 :     declare_eigen_system_h<double>(m, "Real");
      43           1 :     declare_eigen_system_h<std::complex<double>>(m, "Complex");
      44           1 : }