chore(core): Consistently use std::size_t

Quite a few functions took `int` parameters just to cast them to
`std::size_t` everywhere.

Author: timniederhausen

core/include/gprat/cpu/gp_functions.hpp

@@ -30,9 +30,9 @@ namespace cpu
 std::vector<mutable_tile_data<double>>
 cholesky(const std::vector<double> &training_input,
          const SEKParams &sek_params,
-         int n_tiles,
-         int n_tile_size,
-         int n_regressors);
+         std::size_t n_tiles,
+         std::size_t n_tile_size,
+         std::size_t n_regressors);
 
 /**
  * @brief Compute the predictions without uncertainties.
@@ -54,11 +54,11 @@ predict(const std::vector<double> &training_input,
         const std::vector<double> &training_output,
         const std::vector<double> &test_input,
         const SEKParams &sek_params,
-        int n_tiles,
-        int n_tile_size,
-        int m_tiles,
-        int m_tile_size,
-        int n_regressors);
+        std::size_t n_tiles,
+        std::size_t n_tile_size,
+        std::size_t m_tiles,
+        std::size_t m_tile_size,
+        std::size_t n_regressors);
 
 /**
  * @brief Compute the predictions with uncertainties.
@@ -80,11 +80,11 @@ std::vector<std::vector<double>> predict_with_uncertainty(
     const std::vector<double> &training_output,
     const std::vector<double> &test_input,
     const SEKParams &sek_params,
-    int n_tiles,
-    int n_tile_size,
-    int m_tiles,
-    int m_tile_size,
-    int n_regressors);
+    std::size_t n_tiles,
+    std::size_t n_tile_size,
+    std::size_t m_tiles,
+    std::size_t m_tile_size,
+    std::size_t n_regressors);
 
 /**
  * @brief Compute the predictions with full covariance matrix.
@@ -106,11 +106,11 @@ std::vector<std::vector<double>> predict_with_full_cov(
     const std::vector<double> &training_output,
     const std::vector<double> &test_data,
     const SEKParams &sek_params,
-    int n_tiles,
-    int n_tile_size,
-    int m_tiles,
-    int m_tile_size,
-    int n_regressors);
+    std::size_t n_tiles,
+    std::size_t n_tile_size,
+    std::size_t m_tiles,
+    std::size_t m_tile_size,
+    std::size_t n_regressors);
 
 /**
  * @brief Compute loss for given data and Gaussian process model
@@ -127,9 +127,9 @@ 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 SEKParams &sek_params,
-                    int n_tiles,
-                    int n_tile_size,
-                    int n_regressors);
+                    std::size_t n_tiles,
+                    std::size_t n_tile_size,
+                    std::size_t n_regressors);
 
 /**
  * @brief Perform optimization for a given number of iterations

core/include/gprat/cpu/tiled_algorithms.hpp

@@ -28,7 +28,7 @@ namespace cpu
  * @param N Tile size per dimension.
  * @param n_tiles Number of tiles per dimension.
  */
-void right_looking_cholesky_tiled(Tiled_matrix &ft_tiles, int N, std::size_t n_tiles);
+void right_looking_cholesky_tiled(Tiled_matrix &ft_tiles, std::size_t N, std::size_t n_tiles);
 
 // Tiled Triangular Solve Algorithms
 
@@ -40,7 +40,7 @@ void right_looking_cholesky_tiled(Tiled_matrix &ft_tiles, int N, std::size_t n_t
  * @param N Tile size per dimension.
  * @param n_tiles Number of tiles per dimension.
  */
-void forward_solve_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_rhs, int N, std::size_t n_tiles);
+void forward_solve_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_rhs, std::size_t N, std::size_t n_tiles);
 
 /**
  * @brief Perform tiled backward triangular matrix-vector solve.
@@ -50,7 +50,7 @@ void forward_solve_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_rhs, int N, st
  * @param N Tile size per dimension.
  * @param n_tiles Number of tiles per dimension.
  */
-void backward_solve_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_rhs, int N, std::size_t n_tiles);
+void backward_solve_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_rhs, std::size_t N, std::size_t n_tiles);
 
 /**
  * @brief Perform tiled forward triangular matrix-matrix solve.
@@ -62,8 +62,12 @@ void backward_solve_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_rhs, int N, s
  * @param n_tiles Number of tiles in first dimension.
  * @param m_tiles Number of tiles in second dimension.
  */
-void forward_solve_tiled_matrix(
-    Tiled_matrix &ft_tiles, Tiled_matrix &ft_rhs, int N, int M, std::size_t n_tiles, std::size_t m_tiles);
+void forward_solve_tiled_matrix(Tiled_matrix &ft_tiles,
+                                Tiled_matrix &ft_rhs,
+                                std::size_t N,
+                                std::size_t M,
+                                std::size_t n_tiles,
+                                std::size_t m_tiles);
 
 /**
  * @brief Perform tiled backward triangular matrix-matrix solve.
@@ -75,15 +79,19 @@ void forward_solve_tiled_matrix(
  * @param n_tiles Number of tiles in first dimension.
  * @param m_tiles Number of tiles in second dimension.
  */
-void backward_solve_tiled_matrix(
-    Tiled_matrix &ft_tiles, Tiled_matrix &ft_rhs, int N, int M, std::size_t n_tiles, std::size_t m_tiles);
+void backward_solve_tiled_matrix(Tiled_matrix &ft_tiles,
+                                 Tiled_matrix &ft_rhs,
+                                 std::size_t N,
+                                 std::size_t M,
+                                 std::size_t n_tiles,
+                                 std::size_t m_tiles);
 
 /**
  * @brief Perform tiled matrix-vector multiplication
  *
  * @param ft_tiles Tiled matrix represented as a vector of futurized tiles.
  * @param ft_vector Tiled vector represented as a vector of futurized tiles.
- * @param ft_rhsTiled solution represented as a vector of futurized tiles.
+ * @param ft_rhs Tiled solution represented as a vector of futurized tiles.
  * @param N_row Tile size of first dimension.
  * @param N_col Tile size of second dimension.
  * @param n_tiles Number of tiles in first dimension.
@@ -92,8 +100,8 @@ void backward_solve_tiled_matrix(
 void matrix_vector_tiled(Tiled_matrix &ft_tiles,
                          Tiled_vector &ft_vector,
                          Tiled_vector &ft_rhs,
-                         int N_row,
-                         int N_col,
+                         std::size_t N_row,
+                         std::size_t N_col,
                          std::size_t n_tiles,
                          std::size_t m_tiles);
 
@@ -108,7 +116,12 @@ void matrix_vector_tiled(Tiled_matrix &ft_tiles,
  * @param m_tiles Number of tiles in second dimension.
  */
 void symmetric_matrix_matrix_diagonal_tiled(
-    Tiled_matrix &ft_tiles, Tiled_vector &ft_vector, int N, int M, std::size_t n_tiles, std::size_t m_tiles);
+    Tiled_matrix &ft_tiles,
+    Tiled_vector &ft_vector,
+    std::size_t N,
+    std::size_t M,
+    std::size_t n_tiles,
+    std::size_t m_tiles);
 
 /**
  * @brief Perform tiled symmetric k-rank update (ft_tiles^T * ft_tiles)
@@ -120,18 +133,21 @@ void symmetric_matrix_matrix_diagonal_tiled(
  * @param n_tiles Number of tiles in first dimension.
  * @param m_tiles Number of tiles in second dimension.
  */
-void symmetric_matrix_matrix_tiled(
-    Tiled_matrix &ft_tiles, Tiled_matrix &ft_result, int N, int M, std::size_t n_tiles, std::size_t m_tiles);
+void symmetric_matrix_matrix_tiled(Tiled_matrix &ft_tiles,
+                                   Tiled_matrix &ft_result,
+                                   std::size_t N,
+                                   std::size_t M,
+                                   std::size_t n_tiles,
+                                   std::size_t m_tiles);
 
 /**
  * @brief Compute the difference between two tiled vectors
  * @param ft_minuend Tiled vector that is being subtracted from.
  * @param ft_subtrahend Tiled vector that is being subtracted.
- * @param ft_difference Tiled vector that contains the result of the substraction.
  * @param M Tile size dimension.
  * @param m_tiles Number of tiles.
  */
-void vector_difference_tiled(Tiled_vector &ft_minuend, Tiled_vector &ft_substrahend, int M, std::size_t m_tiles);
+void vector_difference_tiled(Tiled_vector &ft_minuend, Tiled_vector &ft_subtrahend, std::size_t M, std::size_t m_tiles);
 
 /**
  * @brief Extract the tiled diagonals of a tiled matrix
@@ -140,7 +156,7 @@ void vector_difference_tiled(Tiled_vector &ft_minuend, Tiled_vector &ft_substrah
  * @param M Tile size per dimension.
  * @param m_tiles Number of tiles per dimension.
  */
-void matrix_diagonal_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_vector, int M, std::size_t m_tiles);
+void matrix_diagonal_tiled(Tiled_matrix &ft_tiles, Tiled_vector &ft_vector, std::size_t M, std::size_t m_tiles);
 
 /**
  * @brief Compute the negative log likelihood loss with a tiled covariance matrix K.
@@ -158,14 +174,14 @@ void compute_loss_tiled(Tiled_matrix &ft_tiles,
                         Tiled_vector &ft_alpha,
                         Tiled_vector &ft_y,
                         hpx::shared_future<double> &loss,
-                        int N,
+                        std::size_t N,
                         std::size_t n_tiles);
 
 /**
  * @brief Updates a hyperparameter of the SEK kernel using Adam
  *
  * @param ft_invK Tiled inverse of the covariance matrix K represented as a vector of futurized tiles.
- * @param ft_grad_param Tiled covariance matrix gradient w.r.t. a hyperparameter.
+ * @param ft_gradK_param Tiled covariance matrix gradient w.r.t. a hyperparameter.
  * @param ft_alpha Tiled vector containing the precomputed inv(K) * y where y is the training output.
  * @param adam_params Hyperparameter of the Adam optimizer
  * @param sek_params Hyperparameters of the SEK kernel
@@ -180,7 +196,7 @@ void update_hyperparameter_tiled(
     const Tiled_vector &ft_alpha,
     const AdamParams &adam_params,
     SEKParams &sek_params,
-    int N,
+    std::size_t N,
     std::size_t n_tiles,
     std::size_t iter,
     std::size_t param_idx);

core/include/gprat/gprat.hpp

@@ -27,10 +27,10 @@ struct GP_data
     std::string file_path;
 
     /** @brief Number of samples in the data */
-    int n_samples;
+    std::size_t n_samples;
 
     /** @brief Number of GP regressors */
-    int n_regressors;
+    std::size_t n_regressors;
 
     /** @brief Vector containing the data */
     std::vector<double> data;
@@ -41,10 +41,10 @@ struct GP_data
      *
      * The file specified by `f_path` must contain `n` samples.
      *
-     * @param f_path Path to the file
+     * @param file_path Path to the file
      * @param n Number of samples
      */
-    GP_data(const std::string &file_path, int n, int n_reg);
+    GP_data(const std::string &file_path, std::size_t n, std::size_t n_reg);
 };
 
 /**
@@ -64,10 +64,10 @@ class GP
     std::vector<double> training_output_;
 
     /** @brief Number of tiles */
-    int n_tiles_;
+    std::size_t n_tiles_;
 
     /** @brief Size of each tile in each dimension */
-    int n_tile_size_;
+    std::size_t n_tile_size_;
 
     /**
      * @brief List of bools indicating trainable parameters: lengthscale,
@@ -82,7 +82,7 @@ class GP
 
   public:
     /** @brief Number of regressors */
-    int n_reg;
+    std::size_t n_reg;
 
     /**
      * @brief Hyperarameters of the squared exponential kernel
@@ -105,10 +105,10 @@ class GP
      */
     GP(std::vector<double> input,
        std::vector<double> output,
-       int n_tiles,
-       int n_tile_size,
-       int n_regressors,
-       std::vector<double> kernel_hyperparams,
+       std::size_t n_tiles,
+       std::size_t n_tile_size,
+       std::size_t n_regressors,
+       const std::vector<double> &kernel_hyperparams,
        std::vector<bool> trainable_bool,
        std::shared_ptr<Target> target);
 
@@ -127,10 +127,10 @@ class GP
      */
     GP(std::vector<double> input,
        std::vector<double> output,
-       int n_tiles,
-       int n_tile_size,
-       int n_regressors,
-       std::vector<double> kernel_hyperparams,
+       std::size_t n_tiles,
+       std::size_t n_tile_size,
+       std::size_t n_regressors,
+       const std::vector<double> &kernel_hyperparams,
        std::vector<bool> trainable_bool);
 
     /**
@@ -150,10 +150,10 @@ class GP
      */
     GP(std::vector<double> input,
        std::vector<double> output,
-       int n_tiles,
-       int n_tile_size,
-       int n_regressors,
-       std::vector<double> kernel_hyperparams,
+       std::size_t n_tiles,
+       std::size_t n_tile_size,
+       std::size_t n_regressors,
+       const std::vector<double> &kernel_hyperparams,
        std::vector<bool> trainable_bool,
        int gpu_id,
        int n_streams);
@@ -176,14 +176,14 @@ class GP
     /**
      * @brief Predict output for test input
      */
-    std::vector<double> predict(const std::vector<double> &test_data, int m_tiles, int m_tile_size);
+    std::vector<double> predict(const std::vector<double> &test_data, std::size_t m_tiles, std::size_t m_tile_size);
 
     /**
      * @brief Predict output for test input and additionally provide
      * uncertainty for the predictions.
      */
     std::vector<std::vector<double>>
-    predict_with_uncertainty(const std::vector<double> &test_data, int m_tiles, int m_tile_size);
+    predict_with_uncertainty(const std::vector<double> &test_data, std::size_t m_tiles, std::size_t m_tile_size);
 
     /**
      * @brief Predict output for test input and additionally compute full
@@ -196,7 +196,7 @@ class GP
      * @return Full covariance matrix
      */
     std::vector<std::vector<double>>
-    predict_with_full_cov(const std::vector<double> &test_data, int m_tiles, int m_tile_size);
+    predict_with_full_cov(const std::vector<double> &test_data, std::size_t m_tiles, std::size_t m_tile_size);
 
     /**
      * @brief Optimize hyperparameters
@@ -217,7 +217,7 @@ class GP
      *
      * @return loss
      */
-    double optimize_step(AdamParams &adam_params, int iter);
+    double optimize_step(AdamParams &adam_params, std::size_t iter);
 
     /**
      * @brief Calculate loss for given data and Gaussian process model

core/include/gprat/utils.hpp

@@ -20,16 +20,16 @@ GPRAT_NS_BEGIN
  * @param n_samples Number of samples
  * @param n_tile_size Size of each tile
  */
-int compute_train_tiles(int n_samples, int n_tile_size);
+std::size_t compute_train_tiles(std::size_t n_samples, std::size_t n_tile_size);
 
 /**
  * @brief Compute the number of tiles for training data, given the number of
  * samples and the size of each tile.
  *
  * @param n_samples Number of samples
- * @param n_tile_size Size of each tile
+ * @param n_tiles Size of each tile
  */
-int compute_train_tile_size(int n_samples, int n_tiles);
+std::size_t compute_train_tile_size(std::size_t n_samples, std::size_t n_tiles);
 
 /**
  * @brief Compute the number of test tiles and the size of a test tile.
@@ -41,15 +41,16 @@ int compute_train_tile_size(int n_samples, int n_tiles);
  * @param n_tiles Number of tiles
  * @param n_tile_size Size of each tile
  */
-std::pair<int, int> compute_test_tiles(int n_test, int n_tiles, int n_tile_size);
+std::pair<std::size_t, std::size_t>
+compute_test_tiles(std::size_t n_test, std::size_t n_tiles, std::size_t n_tile_size);
 
 /**
  * @brief Load data from file
  *
  * @param file_path Path to the file
  * @param n_samples Number of samples to load
  */
-std::vector<double> load_data(const std::string &file_path, int n_samples, int offset);
+std::vector<double> load_data(const std::string &file_path, std::size_t n_samples, std::size_t offset);
 
 /**
  * @brief Print a vector