Add install cmake/make target

* Fix BinDisc quantile mistakes

* Fix FImdlp tests

* Fix tests, samples and remove uneeded support files

* Add coypright header to sources
Fix coverage report
Add coverage badge to README

* Update sonar github action

* Move sources to a folder and change ArffFiles files to library

* Add recursive submodules to github action

.github/workflows/build.yml

@@ -13,9 +13,10 @@ jobs:
     env:
       BUILD_WRAPPER_OUT_DIR: build_wrapper_output_directory # Directory where build-wrapper output will be placed
     steps:
-      - uses: actions/checkout@v4.1.6
+      - 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
@@ -28,17 +29,16 @@ 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 -DENABLE_TESTING=ON
-          build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} cmake --build build/ --config Release
+          cmake -S . -B build -Wno-dev -DCMAKE_PREFIX_PATH=$(pwd)/libtorch -DCMAKE_BUILD_TYPE=Debug -DENABLE_TESTING=ON
+          build-wrapper-linux-x86-64 --out-dir ${{ env.BUILD_WRAPPER_OUT_DIR }} cmake --build build/ --config Debug
+          cmake --build build -j 4
           cd build
-          make
-          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
+          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
       - 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 }}" \
-                        --define sonar.coverageReportPaths=coverage.xml
+          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,11 +1,44 @@
 cmake_minimum_required(VERSION 3.20)
-project(mdlp)
+
+project(fimdlp)
 set(CMAKE_CXX_STANDARD 17)
-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)
+cmake_policy(SET CMP0135 NEW)
+
+find_package(Torch CONFIG REQUIRED)
+
+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")

Makefile

@@ -1,13 +1,35 @@
 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
-	@cmake --build build_release
+	@cmake -B build_release -S . -DCMAKE_BUILD_TYPE=Release -DENABLE_TESTING=OFF -DENABLE_SAMPLE=ON
+	@cmake --build build_release -j 8
+
+install:
+	@cmake --build build_release --target install -j 8		
 
 test:
-	@echo "Testing..."
-	@cd tests && ./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 --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

README.md

@@ -1,6 +1,7 @@
 [![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
 
@@ -31,15 +32,14 @@ Other features:
 To run the sample, just execute the following commands:
 
 ```bash
-cmake -B build -S .
-cmake --build build
-build/sample/sample -f iris -m 2
-build/sample/sample -h
+make build
+build_release/sample/sample -f iris -m 2
+build_release/sample/sample -h
 ```
 
 ## Test
 
-To run the tests and see coverage (llvm & gcovr have to be installed), execute the following commands:
+To run the tests and see coverage (llvm with lcov and genhtml have to be installed), execute the following commands:
 
 ```bash
 make test

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)
-target_link_libraries(sample mdlp "${TORCH_LIBRARIES}")
+include_directories(
+    ${fimdlp_SOURCE_DIR}/src
+    ${fimdlp_SOURCE_DIR}/tests/lib/Files
+)
+
+add_executable(sample sample.cpp )
+target_link_libraries(sample fimdlp "${TORCH_LIBRARIES}")

sample/sample.cpp

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

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

src/BinDisc.cpp

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

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

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

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

src/Discretizer.cpp

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

@@ -1,16 +1,23 @@
+// ****************************************************************
+// 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 <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;
@@ -19,12 +26,11 @@ 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_);
-        static inline std::string version() { return "1.2.3"; };
+        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 "2.0.1"; };
     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

src/Metrics.cpp

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

src/Metrics.h

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

src/typesFImdlp.h

@@ -1,3 +1,9 @@
+// ****************************************************************
+// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
+// SPDX - FileType: SOURCE
+// SPDX - License - Identifier: MIT
+// ****************************************************************
+
 #ifndef TYPES_H
 #define TYPES_H
 
@@ -8,8 +14,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,132 +0,0 @@
-#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,35 +0,0 @@
-#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,9 +1,15 @@
+// ****************************************************************
+// 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.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}
+        ${fimdlp_SOURCE_DIR}/src
+        ${fimdlp_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 ${fimdlp_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
+${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.cpp ArffFiles.cpp BinDisc_unittest.cpp ../Discretizer.cpp)
+add_executable(BinDisc_unittest BinDisc_unittest.cpp ${fimdlp_SOURCE_DIR}/src/BinDisc.cpp  ${fimdlp_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
+${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,11 +1,17 @@
+// ****************************************************************
+// 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 "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;
@@ -20,14 +26,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("1.2.3", version);
+        EXPECT_EQ("2.0.1", version);
     }
     TEST(Discretizer, BinIrisUniform)
     {
@@ -51,9 +57,42 @@ 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(expected, Xt);
+        EXPECT_EQ(iris_quantile, 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,3 +1,9 @@
+// ****************************************************************
+// SPDX - FileCopyrightText: Copyright 2024 Ricardo Montañana Gómez
+// SPDX - FileType: SOURCE
+// SPDX - License - Identifier: MIT
+// ****************************************************************
+
 #ifndef EXPERIMENTS_HPP
 #define EXPERIMENTS_HPP
 #include<sstream>
@@ -6,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

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

@@ -1,5 +1,11 @@
+// ****************************************************************
+// 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

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

tests/Testing/Temporary/LastTest.log

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

tests/test

@@ -1,15 +0,0 @@
-#!/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,3 +1,9 @@
+# ***************************************************************
+# 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.11.8"
+   "version": "3.1.undefined"
   }
  },
  "nbformat": 4,

update_coverage.py

@@ -0,0 +1,38 @@
+# ***************************************************************
+# 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}")