Merge a2ba5ee7e0 into 7b0673fd4b

Fix coverage report
Add coverage badge to README

.github/workflows/build.yml

@@ -16,7 +16,6 @@ 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
@@ -34,11 +33,11 @@ jobs:
           cmake --build build -j 4
           cd build
           ctest -C Debug --output-on-failure -j 4
-          gcovr -f ../src/CPPFImdlp.cpp -f ../src/Metrics.cpp -f ../src/BinDisc.cpp -f ../src/Discretizer.cpp --txt --sonarqube=coverage.xml
+          gcovr -f ../CPPFImdlp.cpp -f ../Metrics.cpp -f ../BinDisc.cpp -f ../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.compile-commands="${{ env.BUILD_WRAPPER_OUT_DIR }}" \
+          sonar-scanner --define sonar.cfamily.build-wrapper-output="${{ env.BUILD_WRAPPER_OUT_DIR }}" \
                         --define sonar.coverageReportPaths=build/coverage.xml

.gitmodules

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

BinDisc.cpp

@@ -54,30 +54,31 @@ namespace mdlp {
         }
         return linspc;
     }
-    size_t clip(const size_t n, const size_t lower, const size_t upper)
+    size_t clip(const size_t n, size_t lower, size_t upper)
     {
         return std::max(lower, std::min(n, upper));
     }
-    std::vector<precision_t> percentile(samples_t& data, const std::vector<precision_t>& percentiles)
+    std::vector<precision_t> percentile(samples_t& data, 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 auto i = static_cast<size_t>(std::floor(static_cast<precision_t>(data.size() - 1) * percentile / 100.));
+            const size_t 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 precision_t percentI = static_cast<precision_t>(indexLower) / static_cast<precision_t>(data.size() - 1);
+            const double percentI = static_cast<double>(indexLower) / static_cast<double>(data.size() - 1);
-            const precision_t fraction =
+            const double fraction =
                 (percentile / 100.0 - percentI) /
-                (static_cast<precision_t>(indexLower + 1) / static_cast<precision_t>(data.size() - 1) - percentI);
+                (static_cast<double>(indexLower + 1) / static_cast<double>(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
+            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
                 results.push_back(value);
             first = false;
         }
         return results;
     }
-    void BinDisc::fit_quantile(const samples_t& X)
+    void BinDisc::fit_quantile(samples_t& X)
     {
         auto quantiles = linspace(0.0, 100.0, n_bins + 1);
         auto data = X;
@@ -90,9 +91,9 @@ namespace mdlp {
         }
         cutPoints = percentile(data, quantiles);
     }
-    void BinDisc::fit_uniform(const samples_t& X)
+    void BinDisc::fit_uniform(samples_t& X)
     {
-        auto [vmin, vmax] = std::minmax_element(X.begin(), X.end());
+        auto minmax = std::minmax_element(X.begin(), X.end());
-        cutPoints = linspace(*vmin, *vmax, n_bins + 1);
+        cutPoints = linspace(*minmax.first, *minmax.second, 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(const samples_t&);
+        void fit_uniform(samples_t&);
-        void fit_quantile(const samples_t&);
+        void fit_quantile(samples_t&);
         int n_bins;
         strategy_t strategy;
     };

CMakeLists.txt

@@ -1,44 +1,20 @@
 cmake_minimum_required(VERSION 3.20)
-
+project(mdlp)
-project(fimdlp)
 set(CMAKE_CXX_STANDARD 17)
-cmake_policy(SET CMP0135 NEW)
+find_package(Torch REQUIRED)
-
+include_directories(${TORCH_INCLUDE_DIRS})
-find_package(Torch CONFIG REQUIRED)
+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)
-
-if (ENABLE_SAMPLE)
-    message("Building sample")
-    add_subdirectory(sample)
-endif(ENABLE_SAMPLE)
-
-include_directories(
-    ${TORCH_INCLUDE_DIRS}
-    ${fimdlp_SOURCE_DIR}/src
-)
-
-add_library(fimdlp src/CPPFImdlp.cpp src/Metrics.cpp src/BinDisc.cpp src/Discretizer.cpp)
-target_link_libraries(fimdlp "${TORCH_LIBRARIES}")
-
-# Installation
-# ------------
-install(TARGETS fimdlp
-        ARCHIVE DESTINATION lib
-        LIBRARY DESTINATION lib
-        CONFIGURATIONS Release)
-install(DIRECTORY src/ DESTINATION include/fimdlp FILES_MATCHING CONFIGURATIONS Release PATTERN "*.h")

CPPFImdlp.cpp

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

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);
-            auto number = pos - first;
+            int number = pos - first;
-            discretizedData.push_back(static_cast<label_t>(number));
+            discretizedData.push_back(number);
         }
         return discretizedData;
     }
@@ -29,26 +29,26 @@ namespace mdlp {
         fit(X_, y_);
         return transform(X_);
     }
-    void Discretizer::fit_t(const torch::Tensor& X_, const torch::Tensor& y_)
+    void Discretizer::fit_t(torch::Tensor& X_, 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(const torch::Tensor& X_)
+    torch::Tensor Discretizer::transform_t(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_label_t);
+        return torch::tensor(result, torch::kInt32);
     }
-    torch::Tensor Discretizer::fit_transform_t(const torch::Tensor& X_, const torch::Tensor& y_)
+    torch::Tensor Discretizer::fit_transform_t(torch::Tensor& X_, 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_label_t);
+        return torch::tensor(result, torch::kInt32);
     }
 }

Discretizer.h

@@ -9,15 +9,14 @@
 
 #include <string>
 #include <algorithm>
-#include "typesFImdlp.h"
 #include <torch/torch.h>
+#include "typesFImdlp.h"
 
 namespace mdlp {
     enum class bound_dir_t {
         LEFT,
         RIGHT
     };
-    const auto torch_label_t = torch::kInt32;
     class Discretizer {
     public:
         Discretizer() = default;
@@ -26,10 +25,10 @@ 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(const torch::Tensor& X_, const torch::Tensor& y_);
+        void fit_t(torch::Tensor& X_, torch::Tensor& y_);
-        torch::Tensor transform_t(const torch::Tensor& X_);
+        torch::Tensor transform_t(torch::Tensor& X_);
-        torch::Tensor fit_transform_t(const torch::Tensor& X_, const torch::Tensor& y_);
+        torch::Tensor fit_transform_t(torch::Tensor& X_, torch::Tensor& y_);
-        static inline std::string version() { return "2.0.1"; };
+        static inline std::string version() { return "1.2.3"; };
     protected:
         labels_t discretizedData = labels_t();
         cutPoints_t cutPoints; // At least two cutpoints must be provided, the first and the last will be ignored in transform

Makefile

@@ -6,16 +6,13 @@ lcov := lcov
 build: 
 	@if [ -d build_release ]; then rm -fr build_release; fi
 	@mkdir build_release
-	@cmake -B build_release -S . -DCMAKE_BUILD_TYPE=Release -DENABLE_TESTING=OFF -DENABLE_SAMPLE=ON
+	@cmake -B build_release -S . -DCMAKE_BUILD_TYPE=Release -DENABLE_TESTING=OFF
 	@cmake --build build_release -j 8
 
-install:
-	@cmake --build build_release --target install -j 8		
-
 test:
 	@if [ -d build_debug ]; then rm -fr build_debug; fi
 	@mkdir build_debug
-	@cmake -B build_debug -S . -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTING=ON -DENABLE_SAMPLE=ON
+	@cmake -B build_debug -S . -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTING=ON
 	@cmake --build build_debug -j 8
 	@cd build_debug/tests && ctest --output-on-failure -j 8
 	@cd build_debug/tests && $(lcov) --capture --directory ../ --demangle-cpp --ignore-errors source,source --ignore-errors mismatch --output-file coverage.info >/dev/null 2>&1; \

sample/CMakeLists.txt

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

sample/sample.cpp

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

sonar-project.properties

@@ -3,7 +3,7 @@ sonar.organization=rmontanana
 
 # This is the name and version displayed in the SonarCloud UI.
 sonar.projectName=mdlp
-sonar.projectVersion=2.0.1
+sonar.projectVersion=2.0.0
 # sonar.test.exclusions=tests/**
 # sonar.tests=tests/
 # sonar.coverage.exclusions=tests/**,sample/**
@@ -12,3 +12,4 @@ sonar.projectVersion=2.0.1
 
 # Encoding of the source code. Default is default system encoding
 sonar.sourceEncoding=UTF-8
+sonar.cfamily.compile-commands

tests/ArffFiles.cpp

@@ -0,0 +1,138 @@
+// ****************************************************************
+// 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

@@ -0,0 +1,41 @@
+// ****************************************************************
+// 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.hpp>
+#include "ArffFiles.h"
-#include "BinDisc.h"
+#include "../BinDisc.h"
 #include "Experiments.hpp"
 
 namespace mdlp {

tests/CMakeLists.txt

@@ -1,3 +1,6 @@
+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(
@@ -8,30 +11,28 @@ FetchContent_Declare(
 set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
 FetchContent_MakeAvailable(googletest)
 
-include_directories(
+find_package(Torch REQUIRED)
-        ${TORCH_INCLUDE_DIRS}
-        ${fimdlp_SOURCE_DIR}/src
-        ${fimdlp_SOURCE_DIR}/tests/lib/Files
-)
 
-add_executable(Metrics_unittest ${fimdlp_SOURCE_DIR}/src/Metrics.cpp Metrics_unittest.cpp)
+enable_testing()
+
+include_directories(${TORCH_INCLUDE_DIRS})
+
+add_executable(Metrics_unittest ../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 FImdlp_unittest.cpp
+add_executable(FImdlp_unittest ../CPPFImdlp.cpp ArffFiles.cpp ../Metrics.cpp FImdlp_unittest.cpp ../Discretizer.cpp)
-${fimdlp_SOURCE_DIR}/src/CPPFImdlp.cpp ${fimdlp_SOURCE_DIR}/src/Metrics.cpp  ${fimdlp_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_unittest.cpp ${fimdlp_SOURCE_DIR}/src/BinDisc.cpp  ${fimdlp_SOURCE_DIR}/src/Discretizer.cpp)
+add_executable(BinDisc_unittest ../BinDisc.cpp ArffFiles.cpp BinDisc_unittest.cpp ../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 Discretizer_unittest.cpp
+add_executable(Discretizer_unittest ../BinDisc.cpp ../CPPFImdlp.cpp ArffFiles.cpp ../Metrics.cpp ../Discretizer.cpp Discretizer_unittest.cpp)
-${fimdlp_SOURCE_DIR}/src/BinDisc.cpp ${fimdlp_SOURCE_DIR}/src/CPPFImdlp.cpp ${fimdlp_SOURCE_DIR}/src/Metrics.cpp ${fimdlp_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 "Discretizer.h"
+#include "ArffFiles.h"
-#include "BinDisc.h"
+#include "../Discretizer.h"
-#include "CPPFImdlp.h"
+#include "../BinDisc.h"
+#include "../CPPFImdlp.h"
 
 namespace mdlp {
     const float margin = 1e-4;
@@ -33,7 +33,7 @@ namespace mdlp {
         auto version = disc->version();
         delete disc;
         std::cout << "Version computed: " << version;
-        EXPECT_EQ("2.0.1", version);
+        EXPECT_EQ("1.2.3", version);
     }
     TEST(Discretizer, BinIrisUniform)
     {

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.hpp>
+#include "ArffFiles.h"
-#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.1.undefined"
+   "version": "3.11.8"
   }
  },
  "nbformat": 4,

typesFImdlp.h

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #ifndef TYPES_H
 #define TYPES_H
 
@@ -14,9 +8,8 @@
 using namespace std;
 namespace mdlp {
     typedef float precision_t;
-    typedef int label_t;
     typedef std::vector<precision_t> samples_t;
-    typedef std::vector<label_t> labels_t;
+    typedef std::vector<int> 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;