Fix some sonar issues in the code

BinDisc.cpp

@@ -54,31 +54,30 @@ namespace mdlp {
         }
         return linspc;
     }
-    size_t clip(const size_t n, size_t lower, size_t upper)
+    size_t clip(const size_t n, const size_t lower, const size_t upper)
     {
         return std::max(lower, std::min(n, upper));
     }
-    std::vector<precision_t> percentile(samples_t& data, std::vector<precision_t>& percentiles)
+    std::vector<precision_t> percentile(samples_t& data, const std::vector<precision_t>& percentiles)
     {
         // Implementation taken from https://dpilger26.github.io/NumCpp/doxygen/html/percentile_8hpp_source.html
         std::vector<precision_t> results;
         bool first = true;
         results.reserve(percentiles.size());
         for (auto percentile : percentiles) {
-            const size_t i = static_cast<size_t>(std::floor(static_cast<double>(data.size() - 1) * percentile / 100.));
+            const auto i = static_cast<size_t>(std::floor(static_cast<double>(data.size() - 1) * percentile / 100.));
             const auto indexLower = clip(i, 0, data.size() - 2);
             const double percentI = static_cast<double>(indexLower) / static_cast<double>(data.size() - 1);
             const double fraction =
                 (percentile / 100.0 - percentI) /
                 (static_cast<double>(indexLower + 1) / static_cast<double>(data.size() - 1) - percentI);
-            const auto value = data[indexLower] + (data[indexLower + 1] - data[indexLower]) * fraction;
+            if (const auto value = data[indexLower] + (data[indexLower + 1] - data[indexLower]) * fraction; value != results.back() || first) // first needed as results.back() return is undefined for empty vectors
-            if (value != results.back() || first) // first needed as results.back() return is undefined for empty vectors
                 results.push_back(value);
             first = false;
         }
         return results;
     }
-    void BinDisc::fit_quantile(samples_t& X)
+    void BinDisc::fit_quantile(const samples_t& X)
     {
         auto quantiles = linspace(0.0, 100.0, n_bins + 1);
         auto data = X;
@@ -91,9 +90,9 @@ namespace mdlp {
         }
         cutPoints = percentile(data, quantiles);
     }
-    void BinDisc::fit_uniform(samples_t& X)
+    void BinDisc::fit_uniform(const samples_t& X)
     {
-        auto minmax = std::minmax_element(X.begin(), X.end());
+        auto [vmin, vmax] = std::minmax_element(X.begin(), X.end());
-        cutPoints = linspace(*minmax.first, *minmax.second, n_bins + 1);
+        cutPoints = linspace(*vmin, *vmax, n_bins + 1);
     }
 }

BinDisc.h

@@ -24,8 +24,8 @@ namespace mdlp {
         void fit(samples_t& X_, labels_t& y) override;
         void fit(samples_t& X);
     private:
-        void fit_uniform(samples_t&);
+        void fit_uniform(const samples_t&);
-        void fit_quantile(samples_t&);
+        void fit_quantile(const samples_t&);
         int n_bins;
         strategy_t strategy;
     };

CPPFImdlp.cpp

@@ -66,9 +66,9 @@ namespace mdlp {
             }
         }
         // Insert first & last X value to the cutpoints as them shall be ignored in transform
-        auto minmax = std::minmax_element(X.begin(), X.end());
+        auto [vmin, vmax] = std::minmax_element(X.begin(), X.end());
-        cutPoints.push_back(*minmax.second);
+        cutPoints.push_back(*vmax);
-        cutPoints.insert(cutPoints.begin(), *minmax.first);
+        cutPoints.insert(cutPoints.begin(), *vmin);
     }
 
     pair<precision_t, size_t> CPPFImdlp::valueCutPoint(size_t start, size_t cut, size_t end)

Discretizer.cpp

@@ -19,7 +19,7 @@ namespace mdlp {
         auto bound = direction == bound_dir_t::LEFT ? std::lower_bound<std::vector<precision_t>::iterator, precision_t> : std::upper_bound<std::vector<precision_t>::iterator, precision_t>;
         for (const precision_t& item : data) {
             auto pos = bound(first, last, item);
-            int number = pos - first;
+            auto number = pos - first;
             discretizedData.push_back(number);
         }
         return discretizedData;
@@ -29,21 +29,21 @@ namespace mdlp {
         fit(X_, y_);
         return transform(X_);
     }
-    void Discretizer::fit_t(torch::Tensor& X_, torch::Tensor& y_)
+    void Discretizer::fit_t(const torch::Tensor& X_, const torch::Tensor& y_)
     {
         auto num_elements = X_.numel();
         samples_t X(X_.data_ptr<precision_t>(), X_.data_ptr<precision_t>() + num_elements);
         labels_t y(y_.data_ptr<int>(), y_.data_ptr<int>() + num_elements);
         fit(X, y);
     }
-    torch::Tensor Discretizer::transform_t(torch::Tensor& X_)
+    torch::Tensor Discretizer::transform_t(const torch::Tensor& X_)
     {
         auto num_elements = X_.numel();
         samples_t X(X_.data_ptr<precision_t>(), X_.data_ptr<precision_t>() + num_elements);
         auto result = transform(X);
         return torch::tensor(result, torch::kInt32);
     }
-    torch::Tensor Discretizer::fit_transform_t(torch::Tensor& X_, torch::Tensor& y_)
+    torch::Tensor Discretizer::fit_transform_t(const torch::Tensor& X_, const torch::Tensor& y_)
     {
         auto num_elements = X_.numel();
         samples_t X(X_.data_ptr<precision_t>(), X_.data_ptr<precision_t>() + num_elements);

Discretizer.h

@@ -25,9 +25,9 @@ namespace mdlp {
         virtual void fit(samples_t& X_, labels_t& y_) = 0;
         labels_t& transform(const samples_t& data);
         labels_t& fit_transform(samples_t& X_, labels_t& y_);
-        void fit_t(torch::Tensor& X_, torch::Tensor& y_);
+        void fit_t(const torch::Tensor& X_, const torch::Tensor& y_);
-        torch::Tensor transform_t(torch::Tensor& X_);
+        torch::Tensor transform_t(const torch::Tensor& X_);
-        torch::Tensor fit_transform_t(torch::Tensor& X_, torch::Tensor& y_);
+        torch::Tensor fit_transform_t(const torch::Tensor& X_, const torch::Tensor& y_);
         static inline std::string version() { return "1.2.3"; };
     protected:
         labels_t discretizedData = labels_t();