refactor!(core): Move everything into the gprat namespace

Author: timniederhausen

bindings/gprat_py.cpp

@@ -1,4 +1,5 @@
 #include "gprat/gprat_c.hpp"
+
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
@@ -31,19 +32,19 @@ void init_gprat(py::module &m)
     // Set hyperparameters to default values in `AdamParams` class, unless
     // specified. Python object has full access to each hyperparameter and a
     // string representation `__repr__`.
-    py::class_<gprat_hyper::AdamParams>(m, "AdamParams")
+    py::class_<gprat::AdamParams>(m, "AdamParams")
         .def(py::init<double, double, double, double, int>(),
              py::arg("learning_rate") = 0.001,
              py::arg("beta1") = 0.9,
              py::arg("beta2") = 0.999,
              py::arg("epsilon") = 1e-8,
              py::arg("opt_iter") = 0)
-        .def_readwrite("learning_rate", &gprat_hyper::AdamParams::learning_rate)
-        .def_readwrite("beta1", &gprat_hyper::AdamParams::beta1)
-        .def_readwrite("beta2", &gprat_hyper::AdamParams::beta2)
-        .def_readwrite("epsilon", &gprat_hyper::AdamParams::epsilon)
-        .def_readwrite("opt_iter", &gprat_hyper::AdamParams::opt_iter)
-        .def("__repr__", &gprat_hyper::AdamParams::repr);
+        .def_readwrite("learning_rate", &gprat::AdamParams::learning_rate)
+        .def_readwrite("beta1", &gprat::AdamParams::beta1)
+        .def_readwrite("beta2", &gprat::AdamParams::beta2)
+        .def_readwrite("epsilon", &gprat::AdamParams::epsilon)
+        .def_readwrite("opt_iter", &gprat::AdamParams::opt_iter)
+        .def("__repr__", &gprat::AdamParams::repr);
 
     // Initializes Gaussian Process with `GP` class. Sets default parameters for
     // squared exponential kernel, number of regressors and trainable, unless

bindings/utils_py.cpp

@@ -1,5 +1,6 @@
 #include "gprat/target.hpp"
 #include "gprat/utils_c.hpp"
+
 #include <pybind11/pybind11.h>
 #include <pybind11/stl.h>
 
@@ -32,7 +33,7 @@ void start_hpx_wrapper(std::vector<std::string> args, std::size_t n_cores)
     }
     argv.push_back(nullptr);
     int argc = static_cast<int>(args.size());
-    utils::start_hpx_runtime(argc, argv.data());
+    gprat::start_hpx_runtime(argc, argv.data());
 }
 
 /**
@@ -43,7 +44,7 @@ void start_hpx_wrapper(std::vector<std::string> args, std::size_t n_cores)
 void init_utils(py::module &m)
 {
     m.def("compute_train_tiles",
-          &utils::compute_train_tiles,
+          &gprat::compute_train_tiles,
           py::arg("n_samples"),
           py::arg("n_tile_size"),
           R"pbdoc(
@@ -58,7 +59,7 @@ void init_utils(py::module &m)
           )pbdoc");
 
     m.def("compute_train_tile_size",
-          &utils::compute_train_tile_size,
+          &gprat::compute_train_tile_size,
           py::arg("n_samples"),
           py::arg("n_tiles"),
           R"pbdoc(
@@ -73,7 +74,7 @@ void init_utils(py::module &m)
           )pbdoc");
 
     m.def("compute_test_tiles",
-          &utils::compute_test_tiles,
+          &gprat::compute_test_tiles,
           py::arg("m_samples"),
           py::arg("n_tiles"),
           py::arg("n_tile_size"),
@@ -90,19 +91,19 @@ void init_utils(py::module &m)
           )pbdoc");
 
     m.def("print_vector",
-          &utils::print_vector,
+          &gprat::print_vector,
           py::arg("vec"),
           py::arg("start") = 0,
           py::arg("end") = -1,
           py::arg("separator") = " ",
           "Print elements of a vector with optional start, end, and separator parameters");
 
     m.def("start_hpx", &start_hpx_wrapper, py::arg("args"), py::arg("n_cores"));  // Using the wrapper function
-    m.def("resume_hpx", &utils::resume_hpx_runtime);
-    m.def("suspend_hpx", &utils::suspend_hpx_runtime);
-    m.def("stop_hpx", &utils::stop_hpx_runtime);
+    m.def("resume_hpx", &gprat::resume_hpx_runtime);
+    m.def("suspend_hpx", &gprat::suspend_hpx_runtime);
+    m.def("stop_hpx", &gprat::stop_hpx_runtime);
 
-    m.def("compiled_with_cuda", &utils::compiled_with_cuda, "Check if the code was compiled with CUDA support");
+    m.def("compiled_with_cuda", &gprat::compiled_with_cuda, "Check if the code was compiled with CUDA support");
 
     m.def("print_available_gpus", &gprat::print_available_gpus, "Print available GPUs with their properties");
     m.def("gpu_count", &gprat::gpu_count, "Return the number of available GPUs");

core/include/gprat/cpu/adapter_cblas_fp32.hpp

@@ -1,8 +1,15 @@
-#ifndef CPU_ADAPTER_CBLAS_FP32_H
-#define CPU_ADAPTER_CBLAS_FP32_H
+#ifndef GPRAT_CPU_ADAPTER_CBLAS_FP32_HPP
+#define GPRAT_CPU_ADAPTER_CBLAS_FP32_HPP
+
+#pragma once
+
+#include "gprat/detail/config.hpp"
 
 #include <hpx/future.hpp>
 #include <vector>
+
+GPRAT_NS_BEGIN
+
 using vector_future = hpx::shared_future<std::vector<float>>;
 
 // Constants that are compatible with CBLAS
@@ -145,4 +152,6 @@ vector_future axpy(vector_future f_y, vector_future f_x, const int N);
  */
 float dot(std::vector<float> a, std::vector<float> b, const int N);
 
-#endif  // end of CPU_ADAPTER_CBLAS_FP32_H
+GPRAT_NS_END
+
+#endif

core/include/gprat/cpu/adapter_cblas_fp64.hpp

@@ -1,13 +1,18 @@
-#ifndef CPU_ADAPTER_CBLAS_FP64_H
-#define CPU_ADAPTER_CBLAS_FP64_H
+#ifndef GPRAT_CPU_ADAPTER_CBLAS_FP64_HPP
+#define GPRAT_CPU_ADAPTER_CBLAS_FP64_HPP
+
+#pragma once
+
+#include "gprat/detail/config.hpp"
 
 #include <hpx/future.hpp>
 #include <vector>
 
+GPRAT_NS_BEGIN
+
 using vector_future = hpx::shared_future<std::vector<double>>;
 
 // Constants that are compatible with CBLAS
-
 typedef enum BLAS_TRANSPOSE { Blas_no_trans = 111, Blas_trans = 112 } BLAS_TRANSPOSE;
 
 typedef enum BLAS_SIDE { Blas_left = 141, Blas_right = 142 } BLAS_SIDE;
@@ -147,4 +152,6 @@ vector_future axpy(vector_future f_y, vector_future f_x, const int N);
  */
 double dot(std::vector<double> a, std::vector<double> b, const int N);
 
-#endif  // end of CPU_ADAPTER_CBLAS_FP64_H
+GPRAT_NS_END
+
+#endif

core/include/gprat/cpu/gp_algorithms.hpp

@@ -1,9 +1,15 @@
-#ifndef CPU_GP_ALGORITHMS_H
-#define CPU_GP_ALGORITHMS_H
+#ifndef GPRAT_CPU_GP_ALGORITHMS_HPP
+#define GPRAT_CPU_GP_ALGORITHMS_HPP
+
+#pragma once
+
+#include "gprat/detail/config.hpp"
+#include "gprat/gp_kernels.hpp"
 
-#include "gp_kernels.hpp"
 #include <vector>
 
+GPRAT_NS_BEGIN
+
 namespace cpu
 {
 
@@ -22,7 +28,7 @@ namespace cpu
 double compute_covariance_function(std::size_t i_global,
                                    std::size_t j_global,
                                    std::size_t n_regressors,
-                                   const gprat_hyper::SEKParams &sek_params,
+                                   const SEKParams &sek_params,
                                    const std::vector<double> &i_input,
                                    const std::vector<double> &j_input);
 
@@ -44,7 +50,7 @@ std::vector<double> gen_tile_covariance(
     std::size_t col,
     std::size_t N,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &input);
 
 /**
@@ -66,7 +72,7 @@ std::vector<double> gen_tile_full_prior_covariance(
     std::size_t col,
     std::size_t N,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &input);
 
 /**
@@ -88,7 +94,7 @@ std::vector<double> gen_tile_prior_covariance(
     std::size_t col,
     std::size_t N,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &input);
 
 /**
@@ -111,7 +117,7 @@ std::vector<double> gen_tile_cross_covariance(
     std::size_t N_row,
     std::size_t N_col,
     std::size_t n_regressors,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     const std::vector<double> &row_input,
     const std::vector<double> &col_input);
 
@@ -170,4 +176,6 @@ std::vector<double> gen_tile_identity(std::size_t N);
 
 }  // end of namespace cpu
 
-#endif  // end of CPU_GP_ALGORITHMS_H
+GPRAT_NS_END
+
+#endif

core/include/gprat/cpu/gp_functions.hpp

@@ -1,10 +1,16 @@
-#ifndef CPU_GP_FUNCTIONS_H
-#define CPU_GP_FUNCTIONS_H
+#ifndef GPRAT_CPU_GP_FUNCTIONS_HPP
+#define GPRAT_CPU_GP_FUNCTIONS_HPP
+
+#pragma once
+
+#include "gprat/detail/config.hpp"
+#include "gprat/gp_hyperparameters.hpp"
+#include "gprat/gp_kernels.hpp"
 
-#include "gp_hyperparameters.hpp"
-#include "gp_kernels.hpp"
 #include <vector>
 
+GPRAT_NS_BEGIN
+
 namespace cpu
 {
 
@@ -22,7 +28,7 @@ namespace cpu
  */
 std::vector<std::vector<double>>
 cholesky(const std::vector<double> &training_input,
-         const gprat_hyper::SEKParams &sek_params,
+         const SEKParams &sek_params,
          int n_tiles,
          int n_tile_size,
          int n_regressors);
@@ -46,7 +52,7 @@ std::vector<double>
 predict(const std::vector<double> &training_input,
         const std::vector<double> &training_output,
         const std::vector<double> &test_input,
-        const gprat_hyper::SEKParams &sek_params,
+        const SEKParams &sek_params,
         int n_tiles,
         int n_tile_size,
         int m_tiles,
@@ -72,7 +78,7 @@ std::vector<std::vector<double>> predict_with_uncertainty(
     const std::vector<double> &training_input,
     const std::vector<double> &training_output,
     const std::vector<double> &test_input,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     int n_tiles,
     int n_tile_size,
     int m_tiles,
@@ -98,7 +104,7 @@ std::vector<std::vector<double>> predict_with_full_cov(
     const std::vector<double> &training_input,
     const std::vector<double> &training_output,
     const std::vector<double> &test_data,
-    const gprat_hyper::SEKParams &sek_params,
+    const SEKParams &sek_params,
     int n_tiles,
     int n_tile_size,
     int m_tiles,
@@ -119,7 +125,7 @@ std::vector<std::vector<double>> predict_with_full_cov(
  */
 double compute_loss(const std::vector<double> &training_input,
                     const std::vector<double> &training_output,
-                    const gprat_hyper::SEKParams &sek_params,
+                    const SEKParams &sek_params,
                     int n_tiles,
                     int n_tile_size,
                     int n_regressors);
@@ -146,8 +152,8 @@ optimize(const std::vector<double> &training_input,
          int n_tiles,
          int n_tile_size,
          int n_regressors,
-         const gprat_hyper::AdamParams &adam_params,
-         gprat_hyper::SEKParams &sek_params,
+         const AdamParams &adam_params,
+         SEKParams &sek_params,
          std::vector<bool> trainable_params);
 
 /**
@@ -173,11 +179,13 @@ double optimize_step(const std::vector<double> &training_input,
                      int n_tiles,
                      int n_tile_size,
                      int n_regressors,
-                     gprat_hyper::AdamParams &adam_params,
-                     gprat_hyper::SEKParams &sek_params,
+                     AdamParams &adam_params,
+                     SEKParams &sek_params,
                      std::vector<bool> trainable_params,
                      int iter);
 
 }  // end of namespace cpu
 
-#endif  // end of CPU_GP_FUNCTIONS_H
+GPRAT_NS_END
+
+#endif