Fix tests, samples and remove uneeded support files

.github/workflows/build.yml

@@ -13,10 +13,9 @@ jobs:
     env:
       BUILD_WRAPPER_OUT_DIR: build_wrapper_output_directory # Directory where build-wrapper output will be placed
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v4.1.6
         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
@@ -29,16 +28,17 @@ jobs:
           unzip libtorch-cxx11-abi-shared-with-deps-2.3.1+cpu.zip
       - name: Tests & build-wrapper
         run: |
-          cmake -S . -B build -Wno-dev -DCMAKE_PREFIX_PATH=$(pwd)/libtorch -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTING=ON
+          cmake -S . -B build -Wno-dev -DCMAKE_PREFIX_PATH=$(pwd)/libtorch -DENABLE_TESTING=ON
-          build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} cmake --build build/ --config Debug
+          build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} cmake --build build/ --config Release
-          cmake --build build -j 4
           cd build
-          ctest -C Debug --output-on-failure -j 4
+          make
-          gcovr -f ../src/CPPFImdlp.cpp -f ../src/Metrics.cpp -f ../src/BinDisc.cpp -f ../src/Discretizer.cpp --txt --sonarqube=coverage.xml
+          ctest -C Release --output-on-failure --test-dir tests
+          cd ..
+          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
+                        --define sonar.coverageReportPaths=coverage.xml

.gitmodules

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

BinDisc.cpp

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #include <algorithm>
 #include <cmath>
 #include "BinDisc.h"
@@ -54,30 +48,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 +85,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

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #ifndef BINDISC_H
 #define BINDISC_H
 
@@ -24,8 +18,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,11 @@
 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}")
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}  -fno-elide-constructors")
+add_subdirectory(sample)
-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

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #include <numeric>
 #include <algorithm>
 #include <set>
@@ -66,9 +60,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)

CPPFImdlp.h

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #ifndef CPPFIMDLP_H
 #define CPPFIMDLP_H
 

Discretizer.cpp

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #include "Discretizer.h"
 
 namespace mdlp {
@@ -19,8 +13,13 @@ 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));
+            /*
+            OJO
+            */
+            if (number < 0)
+                throw std::runtime_error("number is less than 0 in discretizer::transform");
+            discretizedData.push_back(number);
         }
         return discretizedData;
     }
@@ -29,26 +28,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

@@ -1,23 +1,16 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #ifndef DISCRETIZER_H
 #define DISCRETIZER_H
 
 #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,11 +19,12 @@ 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:
+        void normalize_cutpoints();
         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
         bound_dir_t direction; // used in transform

Makefile

@@ -1,35 +1,13 @@
 SHELL := /bin/bash
 .DEFAULT_GOAL := build
 .PHONY: build test
-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
+	@cmake --build build_release
-
-install:
-	@cmake --build build_release --target install -j 8		
 
 test:
-	@if [ -d build_debug ]; then rm -fr build_debug; fi
+	@echo "Testing..."
-	@mkdir build_debug
+	@cd tests && ./test
-	@cmake -B build_debug -S . -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTING=ON -DENABLE_SAMPLE=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; \
-	$(lcov) --remove coverage.info '/usr/*' --output-file coverage.info >/dev/null 2>&1; \
-	$(lcov) --remove coverage.info 'lib/*' --output-file coverage.info >/dev/null 2>&1; \
-	$(lcov) --remove coverage.info 'libtorch/*' --output-file coverage.info >/dev/null 2>&1; \
-	$(lcov) --remove coverage.info 'tests/*' --output-file coverage.info >/dev/null 2>&1; \
-	$(lcov) --remove coverage.info 'gtest/*' --output-file coverage.info >/dev/null 2>&1;
-	@genhtml build_debug/tests/coverage.info --demangle-cpp --output-directory build_debug/tests/coverage --title "Discretizer mdlp Coverage Report" -s -k -f --legend
-	@echo "* Coverage report is generated at build_debug/tests/coverage/index.html"
-	@which python || (echo ">>> Please install python"; exit 1)
-	@if [ ! -f build_debug/tests/coverage.info ]; then \
-		echo ">>> No coverage.info file found!"; \
-		exit 1; \
-	fi
-	@echo ">>> Updating coverage badge..."
-	@env python update_coverage.py build_debug/tests

Metrics.cpp

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #include "Metrics.h"
 #include <set>
 #include <cmath>

Metrics.h

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #ifndef CCMETRICS_H
 #define CCMETRICS_H
 

README.md

@@ -1,7 +1,6 @@
 [![Build](https://github.com/rmontanana/mdlp/actions/workflows/build.yml/badge.svg)](https://github.com/rmontanana/mdlp/actions/workflows/build.yml)
 [![Quality Gate Status](https://sonarcloud.io/api/project_badges/measure?project=rmontanana_mdlp&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=rmontanana_mdlp)
 [![Reliability Rating](https://sonarcloud.io/api/project_badges/measure?project=rmontanana_mdlp&metric=reliability_rating)](https://sonarcloud.io/summary/new_code?id=rmontanana_mdlp)
-[![Coverage Badge](https://img.shields.io/badge/Coverage-100,0%25-green)](html/index.html)
 
 # <img src="logo.png" alt="logo" width="50"/> mdlp
 
@@ -32,14 +31,15 @@ Other features:
 To run the sample, just execute the following commands:
 
 ```bash
-make build
+cmake -B build -S .
-build_release/sample/sample -f iris -m 2
+cmake --build build
-build_release/sample/sample -h
+build/sample/sample -f iris -m 2
+build/sample/sample -h
 ```
 
 ## Test
 
-To run the tests and see coverage (llvm with lcov and genhtml have to be installed), execute the following commands:
+To run the tests and see coverage (llvm & gcovr have to be installed), execute the following commands:
 
 ```bash
 make test

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

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #include <iostream>
 #include <vector>
 #include <iomanip>
@@ -12,10 +6,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=1.2.1
 # sonar.test.exclusions=tests/**
 # sonar.tests=tests/
 # sonar.coverage.exclusions=tests/**,sample/**
@@ -11,4 +11,4 @@ sonar.projectVersion=2.0.1
 #sonar.sources=.
 
 # Encoding of the source code. Default is default system encoding
-sonar.sourceEncoding=UTF-8
+sonar.sourceEncoding=UTF-8

tests/ArffFiles.cpp

@@ -0,0 +1,132 @@
+#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,35 @@
+#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

@@ -1,15 +1,9 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #include <fstream>
 #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

@@ -1,17 +1,11 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #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;
@@ -26,14 +20,14 @@ namespace mdlp {
         return "../../tests/datasets/";
     }
     const std::string data_path = set_data_path();
-    const labels_t iris_quantile = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 3, 3, 3, 1, 3, 1, 2, 0, 3, 1, 0, 2, 2, 2, 1, 3, 1, 2, 2, 1, 2, 2, 2, 2, 3, 3, 3, 3, 2, 1, 1, 1, 2, 2, 1, 2, 3, 2, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2, 1, 1, 2, 2, 3, 2, 3, 3, 0, 3, 3, 3, 3, 3, 3, 1, 2, 3, 3, 3, 3, 2, 3, 1, 3, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 2, 2, 3, 2, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 2, 2 };
+
     TEST(Discretizer, Version)
     {
         Discretizer* disc = new BinDisc(4, strategy_t::UNIFORM);
         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)
     {
@@ -57,42 +51,9 @@ namespace mdlp {
         auto y = labels_t();
         disc->fit(X[0], y);
         auto Xt = disc->transform(X[0]);
+        labels_t expected = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 2, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 3, 3, 3, 1, 3, 1, 2, 0, 3, 1, 0, 2, 2, 2, 1, 3, 1, 2, 2, 1, 2, 2, 2, 2, 3, 3, 3, 3, 2, 1, 1, 1, 2, 2, 1, 2, 3, 2, 1, 1, 1, 2, 2, 0, 1, 1, 1, 2, 1, 1, 2, 2, 3, 2, 3, 3, 0, 3, 3, 3, 3, 3, 3, 1, 2, 3, 3, 3, 3, 2, 3, 1, 3, 2, 3, 3, 2, 2, 3, 3, 3, 3, 3, 2, 2, 3, 2, 3, 2, 3, 3, 3, 2, 3, 3, 3, 2, 3, 2, 2 };
         delete disc;
-        EXPECT_EQ(iris_quantile, Xt);
+        EXPECT_EQ(expected, Xt);
-    }
-
-    TEST(Discretizer, BinIrisQuantileTorch)
-    {
-        ArffFiles file;
-        Discretizer* disc = new BinDisc(4, strategy_t::QUANTILE);
-        file.load(data_path + "iris.arff", true);
-        auto X = file.getX();
-        auto y = file.getY();
-        auto X_torch = torch::tensor(X[0], torch::kFloat32);
-        auto yt = torch::tensor(y, torch::kInt32);
-        disc->fit_t(X_torch, yt);
-        torch::Tensor Xt = disc->transform_t(X_torch);
-        delete disc;
-        EXPECT_EQ(iris_quantile.size(), Xt.size(0));
-        for (int i = 0; i < iris_quantile.size(); ++i) {
-            EXPECT_EQ(iris_quantile.at(i), Xt[i].item<int>());
-        }
-    }
-    TEST(Discretizer, BinIrisQuantileTorchFit_transform)
-    {
-        ArffFiles file;
-        Discretizer* disc = new BinDisc(4, strategy_t::QUANTILE);
-        file.load(data_path + "iris.arff", true);
-        auto X = file.getX();
-        auto y = file.getY();
-        auto X_torch = torch::tensor(X[0], torch::kFloat32);
-        auto yt = torch::tensor(y, torch::kInt32);
-        torch::Tensor Xt = disc->fit_transform_t(X_torch, yt);
-        delete disc;
-        EXPECT_EQ(iris_quantile.size(), Xt.size(0));
-        for (int i = 0; i < iris_quantile.size(); ++i) {
-            EXPECT_EQ(iris_quantile.at(i), Xt[i].item<int>());
-        }
     }
 
     TEST(Discretizer, FImdlpIris)

tests/Experiments.hpp

@@ -1,9 +1,3 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #ifndef EXPERIMENTS_HPP
 #define EXPERIMENTS_HPP
 #include<sstream>
@@ -12,7 +6,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

@@ -1,15 +1,9 @@
-// ****************************************************************
+#include "gtest/gtest.h"
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
+#include "../Metrics.h"
-// SPDX - FileType: SOURCE
+#include "../CPPFImdlp.h"
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #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

@@ -1,11 +1,5 @@
-// ****************************************************************
-// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-// SPDX - FileType: SOURCE
-// SPDX - License - Identifier: MIT
-// ****************************************************************
-
 #include "gtest/gtest.h"
-#include "Metrics.h"
+#include "../Metrics.h"
 
 namespace mdlp {
     class TestMetrics : public Metrics, public testing::Test {

tests/Testing/Temporary/CTestCostData.txt

@@ -0,0 +1 @@
+---

tests/Testing/Temporary/LastTest.log

@@ -0,0 +1,3 @@
+Start testing: Jul 03 18:09 CEST
+----------------------------------------------------------
+End testing: Jul 03 18:09 CEST

tests/test

@@ -0,0 +1,15 @@
+#!/bin/bash
+if [ -d build ] && [ "$1" != "run" ]; then
+	rm -fr build
+fi
+if [ -d gcovr-report ] ; then
+	rm -fr gcovr-report
+fi
+cmake -S . -B build -Wno-dev -DCMAKE_BUILD_TYPE=Debug -DCMAKE_CXX_FLAGS="--coverage" -DCMAKE_C_FLAGS="--coverage"
+cmake --build build
+cd build
+ctest --output-on-failure -j 8
+cd ..
+mkdir gcovr-report
+cd ..
+gcovr  --gcov-filter "CPPFImdlp.cpp" --gcov-filter "Metrics.cpp" --gcov-filter "BinDisc.cpp" --gcov-filter "Discretizer.cpp" --txt --sonarqube=tests/gcovr-report/coverage.xml --exclude-noncode-lines

tests/tests_do.py

@@ -1,9 +1,3 @@
-# ***************************************************************
-# SPDX-FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-# SPDX-FileType: SOURCE
-# SPDX-License-Identifier: MIT
-# ***************************************************************
-
 import json
 from sklearn.preprocessing import KBinsDiscretizer
 

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;

update_coverage.py

@@ -1,38 +0,0 @@
-# ***************************************************************
-# SPDX-FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
-# SPDX-FileType: SOURCE
-# SPDX-License-Identifier: MIT
-# ***************************************************************
-
-import subprocess
-import sys
-
-readme_file = "README.md"
-print("Updating coverage...")
-# Generate badge line
-output = subprocess.check_output(
-    "lcov --summary " + sys.argv[1] + "/coverage.info",
-    shell=True,
-)
-value = output.decode("utf-8").strip()
-percentage = 0
-for line in value.splitlines():
-    if "lines" in line:
-        percentage = float(line.split(":")[1].split("%")[0])
-        break
-print(f"Coverage: {percentage}%")
-if percentage < 90:
-    print("⛔Coverage is less than 90%. I won't update the badge.")
-    sys.exit(1)
-percentage_label = str(percentage).replace(".", ",")
-coverage_line = f"[![Coverage Badge](https://img.shields.io/badge/Coverage-{percentage_label}%25-green)](html/index.html)"
-# Update README.md
-with open(readme_file, "r") as f:
-    lines = f.readlines()
-with open(readme_file, "w") as f:
-    for line in lines:
-        if "img.shields.io/badge/Coverage" in line:
-            f.write(coverage_line + "\n")
-        else:
-            f.write(line)
-print(f"✅Coverage updated with value: {percentage}")