started migration to nanobind

Author: jacobdenobel

CMakeLists.txt

@@ -7,8 +7,8 @@ string(REGEX REPLACE "\n$" "" VERSION_STRING "${VERSION_STRING}")
 project(ioh    
     VERSION "${VERSION_STRING}"
     LANGUAGES CXX  
-)   
-  
+)
+
 add_compile_definitions(PROJECT_VER="${CMAKE_PROJECT_VERSION}")
 
 set(CMAKE_CXX_STANDARD 17)  

ioh/CMakeLists.txt

@@ -1,8 +1,42 @@
-add_subdirectory(${EXTERNAL_DIR}/pybind11 build)
+# add_subdirectory(${EXTERNAL_DIR}/pybind11 build)
 
+if (CMAKE_VERSION VERSION_LESS 3.18)
+  set(DEV_MODULE Development)
+else()
+  set(DEV_MODULE Development.Module)
+endif()
+  
+find_package(Python 3.8 COMPONENTS Interpreter ${DEV_MODULE} REQUIRED)
+
+if (NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES)
+  set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build." FORCE)
+  set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS "Debug" "Release" "MinSizeRel" "RelWithDebInfo")
+endif()
+
+execute_process(
+  COMMAND "${Python_EXECUTABLE}" -m nanobind --cmake_dir
+  OUTPUT_STRIP_TRAILING_WHITESPACE OUTPUT_VARIABLE nanobind_ROOT)
+
+find_package(nanobind CONFIG REQUIRED)
 
 file(GLOB SOURCES src/*.cpp)
-pybind11_add_module(iohcpp ${SOURCES})
+nanobind_add_module(iohcpp 
+    src/empirical_attainment.cpp
+    # src/integer.cpp
+    # src/integer_suite.cpp
+    src/ioh.cpp
+    src/pch.cpp
+    # src/logger.cpp
+    src/problem.cpp
+    src/problem_helpers.cpp
+    # src/property.cpp
+    # src/real.cpp
+    # src/real_suite.cpp
+    # src/suite.cpp
+    # src/suite_helpers.cpp
+    src/trigger.cpp
+)
+
 
 target_link_libraries(iohcpp PRIVATE ${PROJECT_NAME})  
 target_compile_definitions(iohcpp PRIVATE VERSION_INFO=${EXAMPLE_VERSION_INFO})

ioh/src/empirical_attainment.cpp

@@ -1,71 +1,73 @@
 #include "pch.hpp"
 
 template <typename T>
-void define_eah_scale(py::module &m, const std::string &name)
+void define_eah_scale(nb::module_ &m, const std::string &name)
 {
     using namespace logger::eah;
+    using BaseScale = Scale<T>;
 
-    py::class_<Scale<T>, std::shared_ptr<Scale<T>>>(m, name.c_str())
-        .def_property_readonly("min", &Scale<T>::min)
-        .def_property_readonly("max", &Scale<T>::max)
-        .def_property_readonly("size", &Scale<T>::size)
-        .def_property_readonly("length", &Scale<T>::length)
-        .def("index", &Scale<T>::index)
-        .def("bounds", &Scale<T>::bounds)
-        .def("__repr__", [name](const Scale<T> &s) {
+    nb::class_<BaseScale>(m, name.c_str())
+        .def_prop_ro("min", &BaseScale::min)
+        .def_prop_ro("max", &BaseScale::max)
+        .def_prop_ro("size", &BaseScale::size)
+        .def_prop_ro("length", &BaseScale::length)
+        .def("index", &BaseScale::index)
+        .def("bounds", &BaseScale::bounds)
+        .def("__repr__", [name](const BaseScale &s) {
             return fmt::format("<{} (({}, {}), {})>", name, s.min(), s.max(), s.size());
         });
 
-    py::class_<LinearScale<T>, Scale<T>, std::shared_ptr<LinearScale<T>>>(m, ("Linear" + name).c_str())
-        .def(py::init<T, T, size_t>())
+    nb::class_<LinearScale<T>, BaseScale>(m, ("Linear" + name).c_str())
+        .def(nb::init<T, T, size_t>())
         .def("step", &LinearScale<T>::step);
-    py::class_<Log2Scale<T>, Scale<T>, std::shared_ptr<Log2Scale<T>>>(m, ("Log2" + name).c_str())
-        .def(py::init<T, T, size_t>());
 
-    py::class_<Log10Scale<T>, Scale<T>, std::shared_ptr<Log10Scale<T>>>(m, ("Log10" + name).c_str())
-        .def(py::init<T, T, size_t>());
+    nb::class_<Log2Scale<T>, BaseScale>(m, ("Log2" + name).c_str())
+        .def(nb::init<T, T, size_t>());
+
+    nb::class_<Log10Scale<T>, BaseScale>(m, ("Log10" + name).c_str())
+        .def(nb::init<T, T, size_t>());
 }
-void define_eah(py::module &m)
+void define_eah(nb::module_ &m)
 {
     using namespace logger;
     auto eah = m.def_submodule("eah");
     define_eah_scale<double>(eah, "RealScale");
     define_eah_scale<size_t>(eah, "IntegerScale");
 
-    py::class_<EAH, Logger, std::shared_ptr<EAH>>(m, "EAH", "Emperical Attainment Histogram Logger")
-        .def(py::init<double, double, size_t, size_t, size_t, size_t>(), py::arg("error_min"), py::arg("error_max"),
-             py::arg("error_buckets"), py::arg("evals_min"), py::arg("evals_max"), py::arg("evals_buckets"))
-        .def(py::init<eah::LinearScale<double> &, eah::LinearScale<size_t> &>(), py::arg("error_scale"),
-             py::arg("eval_scale"))
-        .def(py::init<eah::Log2Scale<double> &, eah::Log2Scale<size_t> &>(), py::arg("error_scale"),
-             py::arg("eval_scale"))
-        .def(py::init<eah::Log10Scale<double> &, eah::Log10Scale<size_t> &>(), py::arg("error_scale"),
-             py::arg("eval_scale"))
+    nb::class_<EAH, Logger>(m, "EAH", "Emperical Attainment Histogram Logger")
+        .def(nb::init<double, double, size_t, size_t, size_t, size_t>(), nb::arg("error_min"), nb::arg("error_max"),
+             nb::arg("error_buckets"), nb::arg("evals_min"), nb::arg("evals_max"), nb::arg("evals_buckets"))
+        .def(nb::init<eah::LinearScale<double> &, eah::LinearScale<size_t> &>(), nb::arg("error_scale"),
+             nb::arg("eval_scale"))
+        .def(nb::init<eah::Log2Scale<double> &, eah::Log2Scale<size_t> &>(), nb::arg("error_scale"),
+             nb::arg("eval_scale"))
+        .def(nb::init<eah::Log10Scale<double> &, eah::Log10Scale<size_t> &>(), nb::arg("error_scale"),
+             nb::arg("eval_scale"))
         .def("at", &logger::EAH::at)
-        .def_property_readonly("data", &logger::EAH::data)
-        .def_property_readonly("size", &logger::EAH::size)
-        .def_property_readonly("error_range", &logger::EAH::error_range, py::return_value_policy::reference)
-        .def_property_readonly("eval_range", &logger::EAH::eval_range, py::return_value_policy::reference)
+        .def_prop_ro("data", &logger::EAH::data)
+        .def_prop_ro("size", &logger::EAH::size)
+        .def_prop_ro("error_range", &logger::EAH::error_range, nb::rv_policy::reference)
+        .def_prop_ro("eval_range", &logger::EAH::eval_range, nb::rv_policy::reference)
         .def("__repr__", [](const logger::EAH &l) { return fmt::format("<EAH {}>", l.size()); });
 }
 
-void define_eaf(py::module &m)
+void define_eaf(nb::module_ &m)
 {
     using namespace logger;
 
     auto eaf = m.def_submodule("eaf");
-    py::class_<eaf::Point, std::shared_ptr<eaf::Point>>(eaf, "Point")
-        .def(py::init<double, size_t>())
+    nb::class_<eaf::Point>(eaf, "Point")
+        .def(nb::init<double, size_t>())
         .def("__repr__", [](const eaf::Point &p) { return fmt::format("<Point {} {}>", p.qual, p.time); });
 
-    py::class_<eaf::RunPoint, eaf::Point, std::shared_ptr<eaf::RunPoint>>(eaf, "RunPoint")
-        .def(py::init<double, size_t, size_t>())
+    nb::class_<eaf::RunPoint, eaf::Point>(eaf, "RunPoint")
+        .def(nb::init<double, size_t, size_t>())
         .def("__repr__",
              [](const eaf::RunPoint &p) { return fmt::format("<RunPoint {} {} {}>", p.qual, p.time, p.run); });
 
-    py::class_<EAF, Logger, std::shared_ptr<EAF>>(m, "EAF", "Emperical Attainment Function Logger")
-        .def(py::init<>())
-        .def_property_readonly("data", py::overload_cast<>(&EAF::data, py::const_))
+    nb::class_<EAF, Logger>(m, "EAF", "Emperical Attainment Function Logger")
+        .def(nb::init<>())
+        .def_prop_ro("data", nb::overload_cast<>(&EAF::data, nb::const_))
         .def("at", [](EAF &f, std::string suite_name, int pb, int dim, int inst, size_t run) {
             const auto cursor = EAF::Cursor(suite_name, pb, dim, inst, run);
             return f.data(cursor);