Try fixing compilation error.

Author: breyerml

src/plssvm/svm/csvm.cpp

@@ -14,6 +14,7 @@
 #include "plssvm/detail/move_only_any.hpp"                 // plssvm::detail::move_only_any
 #include "plssvm/detail/operators.hpp"                     // plssvm operator overloads for vectors
 #include "plssvm/detail/ssize.hpp"                         // plssvm::detail::{ssize_t, ssize}
+#include "plssvm/detail/ssize.hpp"                         // plssvm::detail::ssize_t
 #include "plssvm/detail/tracking/performance_tracker.hpp"  // PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_TRACKING_ENTRY, PLSSVM_DETAIL_TRACKING_PERFORMANCE_TRACKER_ADD_EVENT, plssvm::detail::tracking::tracking_entry
 #include "plssvm/detail/utility.hpp"                       // plssvm::detail::to_underlying
 #include "plssvm/exceptions/exceptions.hpp"                // plssvm::invalid_parameter_exception
@@ -110,7 +111,7 @@ std::pair<soa_matrix<real_type>, std::vector<unsigned long long>> csvm::conjugat
     // -> 0 if the rhs already converged, 1 otherwise
     const auto calculate_rhs_converged_mask = [eps, delta0, &mask](const std::vector<real_type> &delta_vec, const soa_matrix<real_type> &R_matr) {
 #pragma omp parallel for shared(delta_vec, R_matr)
-        for (ssize_t row = 0; row < R_matr.num_rows(); ++row) {
+        for (detail::ssize_t row = 0; row < R_matr.num_rows(); ++row) {
             // check if this rhs is already marked as converged
             if (mask[row] == 1) {
                 // check if this rhs is now converged
@@ -227,44 +228,44 @@ std::pair<std::vector<real_type>, real_type> csvm::perform_dimensional_reduction
 
     const std::chrono::steady_clock::time_point dimension_reduction_start_time = std::chrono::steady_clock::now();
 
-    const ssize_t num_rows_reduced = static_cast<ssize_t>(A.num_rows() - 1);
+    const detail::ssize_t num_rows_reduced = static_cast<ssize_t>(A.num_rows() - 1);
 
     // create q_red vector and calculate QA_costs
     std::vector<real_type> q_red(num_rows_reduced);
     switch (params.kernel_type) {
         case kernel_function_type::linear:
 #pragma omp parallel for default(none) shared(q_red, A) firstprivate(num_rows_reduced)
-            for (ssize_t i = 0; i < num_rows_reduced; ++i) {
+            for (detail::ssize_t i = 0; i < num_rows_reduced; ++i) {
                 q_red[i] = kernel_function<kernel_function_type::linear>(A, i, A, num_rows_reduced);
             }
             break;
         case kernel_function_type::polynomial:
 #pragma omp parallel for default(none) shared(q_red, A, params) firstprivate(num_rows_reduced)
-            for (ssize_t i = 0; i < num_rows_reduced; ++i) {
+            for (detail::ssize_t i = 0; i < num_rows_reduced; ++i) {
                 q_red[i] = kernel_function<kernel_function_type::polynomial>(A, i, A, num_rows_reduced, params.degree, std::get<real_type>(params.gamma), params.coef0);
             }
             break;
         case kernel_function_type::rbf:
 #pragma omp parallel for default(none) shared(q_red, A, params) firstprivate(num_rows_reduced)
-            for (ssize_t i = 0; i < num_rows_reduced; ++i) {
+            for (detail::ssize_t i = 0; i < num_rows_reduced; ++i) {
                 q_red[i] = kernel_function<kernel_function_type::rbf>(A, i, A, num_rows_reduced, std::get<real_type>(params.gamma));
             }
             break;
         case kernel_function_type::sigmoid:
 #pragma omp parallel for default(none) shared(q_red, A, params) firstprivate(num_rows_reduced)
-            for (ssize_t i = 0; i < num_rows_reduced; ++i) {
+            for (detail::ssize_t i = 0; i < num_rows_reduced; ++i) {
                 q_red[i] = kernel_function<kernel_function_type::sigmoid>(A, i, A, num_rows_reduced, std::get<real_type>(params.gamma), params.coef0);
             }
             break;
         case kernel_function_type::laplacian:
 #pragma omp parallel for default(none) shared(q_red, A, params) firstprivate(num_rows_reduced)
-            for (ssize_t i = 0; i < num_rows_reduced; ++i) {
+            for (detail::ssize_t i = 0; i < num_rows_reduced; ++i) {
                 q_red[i] = kernel_function<kernel_function_type::laplacian>(A, i, A, num_rows_reduced, std::get<real_type>(params.gamma));
             }
             break;
         case kernel_function_type::chi_squared:
 #pragma omp parallel for default(none) shared(q_red, A, params) firstprivate(num_rows_reduced)
-            for (ssize_t i = 0; i < num_rows_reduced; ++i) {
+            for (detail::ssize_t i = 0; i < num_rows_reduced; ++i) {
                 q_red[i] = kernel_function<kernel_function_type::chi_squared>(A, i, A, num_rows_reduced, std::get<real_type>(params.gamma));
             }
             break;