Remove typo in github action

.github/workflows/build.yml

@@ -16,6 +16,7 @@ jobs:
       - uses: actions/checkout@v4
         with:
           fetch-depth: 0 # Shallow clones should be disabled for a better relevancy of analysis
+          submodules: recursive
       - name: Install sonar-scanner and build-wrapper
         uses: SonarSource/sonarcloud-github-c-cpp@v2
       - name: Install lcov & gcovr
@@ -33,11 +34,11 @@ jobs:
           cmake --build build -j 4
           cd build
           ctest -C Debug --output-on-failure -j 4
-          gcovr -f ../CPPFImdlp.cpp -f ../Metrics.cpp -f ../BinDisc.cpp -f ../Discretizer.cpp --txt --sonarqube=coverage.xml
+          gcovr -f ../src/CPPFImdlp.cpp -f ../src/Metrics.cpp -f ../src/BinDisc.cpp -f ../src/Discretizer.cpp --txt --sonarqube=coverage.xml
       - name: Run sonar-scanner
         env:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
         run: |
-          sonar-scanner --define sonar.cfamily.build-wrapper-output="${{ env.BUILD_WRAPPER_OUT_DIR }}" \
+          sonar-scanner --define sonar.cfamily.compile-commands="${{ env.BUILD_WRAPPER_OUT_DIR }}" \
                         --define sonar.coverageReportPaths=build/coverage.xml

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "tests/lib/Files"]
+	path = tests/lib/Files
+	url = https://github.com/rmontanana/ArffFiles.git

CMakeLists.txt

@@ -1,20 +1,34 @@
 cmake_minimum_required(VERSION 3.20)
+
 project(mdlp)
 set(CMAKE_CXX_STANDARD 17)
+cmake_policy(SET CMP0135 NEW)
+
 find_package(Torch REQUIRED)
-include_directories(${TORCH_INCLUDE_DIRS})
-add_library(mdlp CPPFImdlp.cpp Metrics.cpp BinDisc.cpp Discretizer.cpp)
-target_link_libraries(mdlp "${TORCH_LIBRARIES}")
-add_subdirectory(sample)
+
 set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}  -fno-elide-constructors")
 set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
 if (NOT ${CMAKE_SYSTEM_NAME} MATCHES "Darwin")
     set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -fno-default-inline")
 endif()
+
 if (ENABLE_TESTING)
     MESSAGE("Debug mode")
     enable_testing()
     set(CODE_COVERAGE ON)
     SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
     add_subdirectory(tests)
+else(ENABLE_TESTING)
+    MESSAGE("Release mode")
 endif(ENABLE_TESTING)
+
+
+add_subdirectory(sample)
+
+include_directories(
+    ${TORCH_INCLUDE_DIRS}
+    ${mdlp_SOURCE_DIR}/src
+)
+
+add_library(mdlp src/CPPFImdlp.cpp src/Metrics.cpp src/BinDisc.cpp src/Discretizer.cpp)
+target_link_libraries(mdlp "${TORCH_LIBRARIES}")

sample/CMakeLists.txt

@@ -2,5 +2,10 @@ set(CMAKE_CXX_STANDARD 17)
 
 set(CMAKE_BUILD_TYPE Debug)
 
-add_executable(sample sample.cpp ../tests/ArffFiles.cpp)
+include_directories(
+    ${mdlp_SOURCE_DIR}/src
+    ${mdlp_SOURCE_DIR}/tests/lib/Files
+)
+
+add_executable(sample sample.cpp )
 target_link_libraries(sample mdlp "${TORCH_LIBRARIES}")

sample/sample.cpp

@@ -12,10 +12,10 @@
 #include <cstring>
 #include <getopt.h>
 #include <torch/torch.h>
-#include "../Discretizer.h"
-#include "../CPPFImdlp.h"
-#include "../BinDisc.h"
-#include "../tests/ArffFiles.h"
+#include <ArffFiles.hpp>
+#include "Discretizer.h"
+#include "CPPFImdlp.h"
+#include "BinDisc.h"
 
 const string PATH = "tests/datasets/";
 

sonar-project.properties

@@ -12,4 +12,3 @@ sonar.projectVersion=2.0.0
 
 # Encoding of the source code. Default is default system encoding
 sonar.sourceEncoding=UTF-8
-sonar.cfamily.compile-commands

src/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<precision_t>(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 =
+            const precision_t percentI = static_cast<precision_t>(indexLower) / static_cast<precision_t>(data.size() - 1);
+            const precision_t 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 (value != results.back() || first) // first needed as results.back() return is undefined for empty vectors
+                (static_cast<precision_t>(indexLower + 1) / static_cast<precision_t>(data.size() - 1) - percentI);
+            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
                 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());
-        cutPoints = linspace(*minmax.first, *minmax.second, n_bins + 1);
+        auto [vmin, vmax] = std::minmax_element(X.begin(), X.end());
+        cutPoints = linspace(*vmin, *vmax, n_bins + 1);
     }
 }

src/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_quantile(samples_t&);
+        void fit_uniform(const samples_t&);
+        void fit_quantile(const samples_t&);
         int n_bins;
         strategy_t strategy;
     };

src/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());
-        cutPoints.push_back(*minmax.second);
-        cutPoints.insert(cutPoints.begin(), *minmax.first);
+        auto [vmin, vmax] = std::minmax_element(X.begin(), X.end());
+        cutPoints.push_back(*vmax);
+        cutPoints.insert(cutPoints.begin(), *vmin);
     }
 
     pair<precision_t, size_t> CPPFImdlp::valueCutPoint(size_t start, size_t cut, size_t end)

src/Discretizer.cpp

@@ -19,8 +19,8 @@ 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;
-            discretizedData.push_back(number);
+            auto number = pos - first;
+            discretizedData.push_back(static_cast<label_t>(number));
         }
         return discretizedData;
     }
@@ -29,26 +29,26 @@ 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);
+        return torch::tensor(result, torch_label_t);
     }
-    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);
         labels_t y(y_.data_ptr<int>(), y_.data_ptr<int>() + num_elements);
         auto result = fit_transform(X, y);
-        return torch::tensor(result, torch::kInt32);
+        return torch::tensor(result, torch_label_t);
     }
 }

src/Discretizer.h

@@ -9,14 +9,15 @@
 
 #include <string>
 #include <algorithm>
-#include <torch/torch.h>
 #include "typesFImdlp.h"
+#include <torch/torch.h>
 
 namespace mdlp {
     enum class bound_dir_t {
         LEFT,
         RIGHT
     };
+    const auto torch_label_t = torch::kInt32;
     class Discretizer {
     public:
         Discretizer() = default;
@@ -25,9 +26,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_);
-        torch::Tensor transform_t(torch::Tensor& X_);
-        torch::Tensor fit_transform_t(torch::Tensor& X_, torch::Tensor& y_);
+        void fit_t(const torch::Tensor& X_, const torch::Tensor& y_);
+        torch::Tensor transform_t(const torch::Tensor& X_);
+        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();

src/typesFImdlp.h

@@ -8,8 +8,9 @@
 using namespace std;
 namespace mdlp {
     typedef float precision_t;
+    typedef int label_t;
     typedef std::vector<precision_t> samples_t;
-    typedef std::vector<int> labels_t;
+    typedef std::vector<label_t> labels_t;
     typedef std::vector<size_t> indices_t;
     typedef std::vector<precision_t> cutPoints_t;
     typedef std::map<std::pair<int, int>, precision_t> cacheEnt_t;

tests/ArffFiles.cpp

@@ -1,138 +0,0 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
-#include "ArffFiles.h"
-#include <fstream>
-#include <sstream>
-#include <map>
-
-using namespace std;
-
-ArffFiles::ArffFiles() = default;
-
-vector<string> ArffFiles::getLines() const
-{
-    return lines;
-}
-
-unsigned long int ArffFiles::getSize() const
-{
-    return lines.size();
-}
-
-vector<pair<string, string>> ArffFiles::getAttributes() const
-{
-    return attributes;
-}
-
-string ArffFiles::getClassName() const
-{
-    return className;
-}
-
-string ArffFiles::getClassType() const
-{
-    return classType;
-}
-
-vector<mdlp::samples_t>& ArffFiles::getX()
-{
-    return X;
-}
-
-vector<int>& ArffFiles::getY()
-{
-    return y;
-}
-
-void ArffFiles::load(const string& fileName, bool classLast)
-{
-    ifstream file(fileName);
-    if (!file.is_open()) {
-        throw invalid_argument("Unable to open file");
-    }
-    string line;
-    string keyword;
-    string attribute;
-    string type;
-    string type_w;
-    while (getline(file, line)) {
-        if (line.empty() || line[0] == '%' || line == "\r" || line == " ") {
-            continue;
-        }
-        if (line.find("@attribute") != string::npos || line.find("@ATTRIBUTE") != string::npos) {
-            stringstream ss(line);
-            ss >> keyword >> attribute;
-            type = "";
-            while (ss >> type_w)
-                type += type_w + " ";
-            attributes.emplace_back(trim(attribute), trim(type));
-            continue;
-        }
-        if (line[0] == '@') {
-            continue;
-        }
-        lines.push_back(line);
-    }
-    file.close();
-    if (attributes.empty())
-        throw invalid_argument("No attributes found");
-    if (classLast) {
-        className = get<0>(attributes.back());
-        classType = get<1>(attributes.back());
-        attributes.pop_back();
-    } else {
-        className = get<0>(attributes.front());
-        classType = get<1>(attributes.front());
-        attributes.erase(attributes.begin());
-    }
-    generateDataset(classLast);
-
-}
-
-void ArffFiles::generateDataset(bool classLast)
-{
-    X = vector<mdlp::samples_t>(attributes.size(), mdlp::samples_t(lines.size()));
-    auto yy = vector<string>(lines.size(), "");
-    int labelIndex = classLast ? static_cast<int>(attributes.size()) : 0;
-    for (size_t i = 0; i < lines.size(); i++) {
-        stringstream ss(lines[i]);
-        string value;
-        int pos = 0;
-        int xIndex = 0;
-        while (getline(ss, value, ',')) {
-            if (pos++ == labelIndex) {
-                yy[i] = value;
-            } else {
-                X[xIndex++][i] = stof(value);
-            }
-        }
-    }
-    y = factorize(yy);
-}
-
-string ArffFiles::trim(const string& source)
-{
-    string s(source);
-    s.erase(0, s.find_first_not_of(" '\n\r\t"));
-    s.erase(s.find_last_not_of(" '\n\r\t") + 1);
-    return s;
-}
-
-vector<int> ArffFiles::factorize(const vector<string>& labels_t)
-{
-    vector<int> yy;
-    yy.reserve(labels_t.size());
-    map<string, int> labelMap;
-    int i = 0;
-    for (const string& label : labels_t) {
-        if (labelMap.find(label) == labelMap.end()) {
-            labelMap[label] = i++;
-        }
-        yy.push_back(labelMap[label]);
-    }
-    return yy;
-}

tests/ArffFiles.h

@@ -1,41 +0,0 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
-#ifndef ARFFFILES_H
-#define ARFFFILES_H
-
-#include <string>
-#include <vector>
-#include "../typesFImdlp.h"
-
-using namespace std;
-
-class ArffFiles {
-private:
-    vector<string> lines;
-    vector<pair<string, string>> attributes;
-    string className;
-    string classType;
-    vector<mdlp::samples_t> X;
-    vector<int> y;
-
-    void generateDataset(bool);
-
-public:
-    ArffFiles();
-    void load(const string&, bool = true);
-    vector<string> getLines() const;
-    unsigned long int getSize() const;
-    string getClassName() const;
-    string getClassType() const;
-    static string trim(const string&);
-    vector<mdlp::samples_t>& getX();
-    vector<int>& getY();
-    vector<pair<string, string>> getAttributes() const;
-    static vector<int> factorize(const vector<string>& labels_t);
-};
-
-#endif

tests/BinDisc_unittest.cpp

@@ -8,8 +8,8 @@
 #include <string>
 #include <iostream>
 #include "gtest/gtest.h"
-#include "ArffFiles.h"
-#include "../BinDisc.h"
+#include <ArffFiles.hpp>
+#include "BinDisc.h"
 #include "Experiments.hpp"
 
 namespace mdlp {

tests/CMakeLists.txt

@@ -1,6 +1,3 @@
-cmake_minimum_required(VERSION 3.20)
-set(CMAKE_CXX_STANDARD 17)
-cmake_policy(SET CMP0135 NEW)
 include(FetchContent)
 include_directories(${GTEST_INCLUDE_DIRS})
 FetchContent_Declare(
@@ -11,28 +8,30 @@ FetchContent_Declare(
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(googletest)
 
-find_package(Torch REQUIRED)
+include_directories(
+        ${TORCH_INCLUDE_DIRS}
+        ${mdlp_SOURCE_DIR}/src
+        ${mdlp_SOURCE_DIR}/tests/lib/Files
+)
 
-enable_testing()
-
-include_directories(${TORCH_INCLUDE_DIRS})
-
-add_executable(Metrics_unittest ../Metrics.cpp Metrics_unittest.cpp)
+add_executable(Metrics_unittest ${mdlp_SOURCE_DIR}/src/Metrics.cpp Metrics_unittest.cpp)
 target_link_libraries(Metrics_unittest GTest::gtest_main)
 target_compile_options(Metrics_unittest PRIVATE --coverage)
 target_link_options(Metrics_unittest PRIVATE --coverage)
 
-add_executable(FImdlp_unittest ../CPPFImdlp.cpp ArffFiles.cpp ../Metrics.cpp FImdlp_unittest.cpp ../Discretizer.cpp)
+add_executable(FImdlp_unittest FImdlp_unittest.cpp
+${mdlp_SOURCE_DIR}/src/CPPFImdlp.cpp ${mdlp_SOURCE_DIR}/src/Metrics.cpp  ${mdlp_SOURCE_DIR}/src/Discretizer.cpp)
 target_link_libraries(FImdlp_unittest GTest::gtest_main "${TORCH_LIBRARIES}")
 target_compile_options(FImdlp_unittest PRIVATE --coverage)
 target_link_options(FImdlp_unittest PRIVATE --coverage)
 
-add_executable(BinDisc_unittest ../BinDisc.cpp ArffFiles.cpp BinDisc_unittest.cpp ../Discretizer.cpp)
+add_executable(BinDisc_unittest BinDisc_unittest.cpp ${mdlp_SOURCE_DIR}/src/BinDisc.cpp  ${mdlp_SOURCE_DIR}/src/Discretizer.cpp)
 target_link_libraries(BinDisc_unittest GTest::gtest_main "${TORCH_LIBRARIES}")
 target_compile_options(BinDisc_unittest PRIVATE --coverage)
 target_link_options(BinDisc_unittest PRIVATE --coverage)
 
-add_executable(Discretizer_unittest ../BinDisc.cpp ../CPPFImdlp.cpp ArffFiles.cpp ../Metrics.cpp ../Discretizer.cpp Discretizer_unittest.cpp)
+add_executable(Discretizer_unittest Discretizer_unittest.cpp
+${mdlp_SOURCE_DIR}/src/BinDisc.cpp ${mdlp_SOURCE_DIR}/src/CPPFImdlp.cpp ${mdlp_SOURCE_DIR}/src/Metrics.cpp ${mdlp_SOURCE_DIR}/src/Discretizer.cpp )
 target_link_libraries(Discretizer_unittest GTest::gtest_main "${TORCH_LIBRARIES}")
 target_compile_options(Discretizer_unittest PRIVATE --coverage)
 target_link_options(Discretizer_unittest PRIVATE --coverage)

tests/Discretizer_unittest.cpp

@@ -7,11 +7,11 @@
 #include <fstream>
 #include <string>
 #include <iostream>
+#include <ArffFiles.hpp>
 #include "gtest/gtest.h"
-#include "ArffFiles.h"
-#include "../Discretizer.h"
-#include "../BinDisc.h"
-#include "../CPPFImdlp.h"
+#include "Discretizer.h"
+#include "BinDisc.h"
+#include "CPPFImdlp.h"
 
 namespace mdlp {
     const float margin = 1e-4;

tests/Experiments.hpp

@@ -12,7 +12,7 @@
 #include<fstream>
 #include<vector>
 #include<tuple>
-#include "../typesFImdlp.h"
+#include "typesFImdlp.h"
 
 template <typename T>
 void show_vector(const std::vector<T>& data, std::string title)

tests/FImdlp_unittest.cpp

@@ -4,12 +4,12 @@
 // SPDX - License - Identifier: MIT
 // ****************************************************************
 
-#include "gtest/gtest.h"
-#include "../Metrics.h"
-#include "../CPPFImdlp.h"
 #include <fstream>
 #include <iostream>
-#include "ArffFiles.h"
+#include <ArffFiles.hpp>
+#include "gtest/gtest.h"
+#include "Metrics.h"
+#include "CPPFImdlp.h"
 
 #define EXPECT_THROW_WITH_MESSAGE(stmt, etype, whatstring) EXPECT_THROW( \
 try { \

tests/Metrics_unittest.cpp

@@ -5,7 +5,7 @@
 // ****************************************************************
 
 #include "gtest/gtest.h"
-#include "../Metrics.h"
+#include "Metrics.h"
 
 namespace mdlp {
     class TestMetrics : public Metrics, public testing::Test {

tests/tests_generate.ipynb

@@ -201,7 +201,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.8"
+   "version": "3.1.undefined"
   }
  },
  "nbformat": 4,