Compiling right

.conan/profiles/default

@@ -0,0 +1,11 @@
+[settings]
+os=Linux
+arch=x86_64
+compiler=gcc
+compiler.version=11
+compiler.libcxx=libstdc++11
+build_type=Release
+
+[conf]
+tools.system.package_manager:mode=install
+tools.system.package_manager:sudo=True

.gitmodules

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

.vscode/settings.json

@@ -104,6 +104,10 @@
         "stop_token": "cpp",
         "text_encoding": "cpp",
         "typeindex": "cpp",
-        "valarray": "cpp"
+        "valarray": "cpp",
+        "csignal": "cpp",
+        "regex": "cpp",
+        "future": "cpp",
+        "shared_mutex": "cpp"
     }
 }

CHANGELOG.md

@@ -0,0 +1,182 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+- Conan dependency manager support
+- Technical analysis report
+
+### Changed
+- Updated README.md
+- Refactored library version and installation system
+- Updated config variable names
+
+### Fixed
+- Removed unneeded semicolon
+
+## [2.0.1] - 2024-07-22
+
+### Added
+- CMake install target and make install command
+- Flag to control sample building in Makefile
+
+### Changed
+- Library name changed to `fimdlp`
+- Updated version numbers across test files
+
+### Fixed
+- Version number consistency in tests
+
+## [2.0.0] - 2024-07-04
+
+### Added
+- Makefile with build & test actions for easier development
+- PyTorch (libtorch) integration for tensor operations
+
+### Changed
+- Major refactoring of build system
+- Updated build workflows and CI configuration
+
+### Fixed
+- BinDisc quantile calculation errors (#9)
+- Error in percentile method calculation
+- Integer type issues in calculations
+- Multiple GitHub Actions configuration fixes
+
+## [1.2.1] - 2024-06-08
+
+### Added
+- PyTorch tensor methods for discretization
+- Improved library build system
+
+### Changed
+- Refactored sample build process
+
+### Fixed
+- Library creation and linking issues
+- Multiple GitHub Actions workflow fixes
+
+## [1.2.0] - 2024-06-05
+
+### Added
+- **Discretizer** - Abstract base class for all discretization algorithms (#8)
+- **BinDisc** - K-bins discretization with quantile and uniform strategies (#7)
+- Transform method to discretize values using existing cut points
+- Support for multiple datasets in sample program
+- Docker development container configuration
+
+### Changed
+- Refactored system types throughout the library
+- Improved sample program with better dataset handling
+- Enhanced build system with debug options
+
+### Fixed
+- Transform method initialization issues
+- ARFF file attribute name extraction
+- Sample program library binary separation
+
+## [1.1.3] - 2024-06-05
+
+### Added
+- `max_cutpoints` hyperparameter for controlling algorithm complexity
+- `max_depth` and `min_length` as configurable hyperparameters
+- Enhanced sample program with hyperparameter support
+- Additional datasets for testing
+
+### Changed
+- Improved constructor design and parameter handling
+- Enhanced test coverage and reporting
+- Refactored build system configuration
+
+### Fixed
+- Depth initialization in fit method
+- Code quality improvements and smell fixes
+- Exception handling in value cut point calculations
+
+## [1.1.2] - 2023-04-01
+
+### Added
+- Comprehensive test suite with GitHub Actions CI
+- SonarCloud integration for code quality analysis
+- Enhanced build system with automated testing
+
+### Changed
+- Improved GitHub Actions workflow configuration
+- Updated project structure for better maintainability
+
+### Fixed
+- Build system configuration issues
+- Test execution and coverage reporting
+
+## [1.1.1] - 2023-02-22
+
+### Added
+- Limits header for proper compilation
+- Enhanced build system support
+
+### Changed
+- Updated version numbering system
+- Improved SonarCloud configuration
+
+### Fixed
+- ValueCutPoint exception handling (removed unnecessary exception)
+- Build system compatibility issues
+- GitHub Actions token configuration
+
+## [1.1.0] - 2023-02-21
+
+### Added
+- Classic algorithm implementation for performance comparison
+- Enhanced ValueCutPoint logic with same_values detection
+- Glass dataset support in sample program
+- Debug configuration for development
+
+### Changed
+- Refactored ValueCutPoint algorithm for better accuracy
+- Improved candidate selection logic
+- Enhanced sample program with multiple datasets
+
+### Fixed
+- Sign error in valueCutPoint calculation
+- Final cut value computation
+- Duplicate dataset handling in sample
+
+## [1.0.0.0] - 2022-12-21
+
+### Added
+- Initial release of MDLP (Minimum Description Length Principle) discretization library
+- Core CPPFImdlp algorithm implementation based on Fayyad & Irani's paper
+- Entropy and information gain calculation methods
+- Sample program demonstrating library usage
+- CMake build system
+- Basic test suite
+- ARFF file format support for datasets
+
+### Features
+- Recursive discretization using entropy-based criteria
+- Stable sorting with tie-breaking for identical values
+- Configurable algorithm parameters
+- Cross-platform C++ implementation
+
+---
+
+## Release Notes
+
+### Version 2.x
+- **Breaking Changes**: Library renamed to `fimdlp`
+- **Major Enhancement**: PyTorch integration for improved performance
+- **New Features**: Comprehensive discretization framework with multiple algorithms
+
+### Version 1.x
+- **Core Algorithm**: MDLP discretization implementation
+- **Extensibility**: Hyperparameter support and algorithm variants
+- **Quality**: Comprehensive testing and CI/CD pipeline
+
+### Version 1.0.x
+- **Foundation**: Initial stable implementation
+- **Algorithm**: Core MDLP discretization functionality

CMakeLists.txt

@@ -4,11 +4,12 @@ project(fimdlp
     LANGUAGES CXX
     DESCRIPTION "Discretization algorithm based on the paper by Fayyad & Irani Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning."
     HOMEPAGE_URL "https://github.com/rmontanana/mdlp"
-    VERSION 2.0.1
+    VERSION 2.1.0
 )
 set(CMAKE_CXX_STANDARD 17)
 cmake_policy(SET CMP0135 NEW)
 
+# Find dependencies
 find_package(Torch REQUIRED)
 
 # Options
@@ -27,6 +28,7 @@ endif()
 
 if (ENABLE_TESTING)
     message("Debug mode")
+    
     enable_testing()
     set(CODE_COVERAGE ON)
     set(GCC_COVERAGE_LINK_FLAGS "${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
@@ -46,7 +48,7 @@ include_directories(
 )
 
 add_library(fimdlp src/CPPFImdlp.cpp src/Metrics.cpp src/BinDisc.cpp src/Discretizer.cpp)
-target_link_libraries(fimdlp torch::torch)
+target_link_libraries(fimdlp PRIVATE torch::torch)
 
 # Installation
 # ------------

CMakeUserPresets.json

@@ -4,6 +4,7 @@
         "conan": {}
     },
     "include": [
-        "build/Release/generators/CMakePresets.json"
+        "build_release/build/Release/generators/CMakePresets.json",
+        "build_debug/build/Debug/generators/CMakePresets.json"
     ]
 }

CONAN_README.md

@@ -0,0 +1,153 @@
+# Conan Package for fimdlp
+
+This directory contains the Conan package configuration for the fimdlp library.
+
+## Dependencies
+
+The package manages the following dependencies:
+
+### Build Requirements
+- **libtorch/2.4.1** - PyTorch C++ library for tensor operations
+
+### Test Requirements (when testing enabled)
+- **catch2/3.8.1** - Modern C++ testing framework
+- **arff-files** - ARFF file format support (included locally in tests/lib/Files/)
+
+## Building with Conan
+
+### 1. Install Dependencies and Build
+
+```bash
+# Install dependencies
+conan install . --output-folder=build --build=missing
+
+# Build the project
+cd build
+cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
+cmake --build .
+```
+
+### 2. Using the Build Script
+
+```bash
+# Build release version
+./scripts/build_conan.sh
+
+# Build with tests
+./scripts/build_conan.sh --test
+```
+
+## Creating a Package
+
+### 1. Create Package Locally
+
+```bash
+conan create . --profile:build=default --profile:host=default
+```
+
+### 2. Create Package with Options
+
+```bash
+# Create with testing enabled
+conan create . -o enable_testing=True --profile:build=default --profile:host=default
+
+# Create shared library version
+conan create . -o shared=True --profile:build=default --profile:host=default
+```
+
+### 3. Using the Package Creation Script
+
+```bash
+./scripts/create_package.sh
+```
+
+## Uploading to Cimmeria
+
+### 1. Configure Remote
+
+```bash
+# Add Cimmeria remote
+conan remote add cimmeria <cimmeria-server-url>
+
+# Login to Cimmeria
+conan remote login cimmeria <username>
+```
+
+### 2. Upload Package
+
+```bash
+# Upload the package
+conan upload fimdlp/2.1.0 --remote=cimmeria --all
+
+# Or use the script (will configure remote instructions if not set up)
+./scripts/create_package.sh
+```
+
+## Using the Package
+
+### In conanfile.txt
+
+```ini
+[requires]
+fimdlp/2.1.0
+
+[generators]
+CMakeDeps
+CMakeToolchain
+```
+
+### In conanfile.py
+
+```python
+def requirements(self):
+    self.requires("fimdlp/2.1.0")
+```
+
+### In CMakeLists.txt
+
+```cmake
+find_package(fimdlp REQUIRED)
+target_link_libraries(your_target fimdlp::fimdlp)
+```
+
+## Package Options
+
+| Option | Values | Default | Description |
+|--------|--------|---------|-------------|
+| shared | True/False | False | Build shared library |
+| fPIC | True/False | True | Position independent code |
+| enable_testing | True/False | False | Enable test suite |
+| enable_sample | True/False | False | Build sample program |
+
+## Example Usage
+
+```cpp
+#include <fimdlp/CPPFImdlp.h>
+#include <fimdlp/Metrics.h>
+
+int main() {
+    // Create MDLP discretizer
+    CPPFImdlp discretizer;
+    
+    // Calculate entropy
+    Metrics metrics;
+    std::vector<int> labels = {0, 1, 0, 1, 1};
+    double entropy = metrics.entropy(labels);
+    
+    return 0;
+}
+```
+
+## Testing
+
+The package includes comprehensive tests that can be enabled with:
+
+```bash
+conan create . -o enable_testing=True
+```
+
+## Requirements
+
+- C++17 compatible compiler
+- CMake 3.20 or later
+- Conan 2.0 or later

Makefile

@@ -1,35 +1,41 @@
 SHELL := /bin/bash
 .DEFAULT_GOAL := build
-.PHONY: build test
+.PHONY: build install 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 --build build_release -j 8
+f_debug = build_debug
+f_release = build_release
 
-install:
+build: ## Build the project for Release
+	@echo ">>> Building the project for Release..."
+	@if [ -d $(f_release) ]; then rm -fr $(f_release); fi
+	@conan install . --build=missing -of $(f_release) -s build_type=Release --profile:build=default --profile:host=default
+	cmake -S . -B $(f_release) -DCMAKE_TOOLCHAIN_FILE=$(f_release)/build/Release/generators/conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release -DENABLE_TESTING=OFF -DENABLE_SAMPLE=ON
+	@cmake --build $(f_release) -j 8
+
+install: ## Install the project
+	@echo ">>> Installing the project..."
 	@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 --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; \
+test: ## Build Debug version and run tests
+	@echo ">>> Building Debug version and running tests..."
+	@if [ -d $(f_debug) ]; then rm -fr $(f_debug); fi
+	@conan install . --build=missing -of $(f_debug) -s build_type=Debug
+	@cmake -B $(f_debug) -S . -DCMAKE_BUILD_TYPE=Debug -DCMAKE_TOOLCHAIN_FILE=$(f_debug)/build/Debug/generators/conan_toolchain.cmake -DENABLE_TESTING=ON -DENABLE_SAMPLE=ON
+	@cmake --build $(f_debug) -j 8
+	@cd $(f_debug)/tests && ctest --output-on-failure -j 8
+	@cd $(f_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"
+	@genhtml $(f_debug)/tests/coverage.info --demangle-cpp --output-directory $(f_debug)/tests/coverage --title "Discretizer mdlp Coverage Report" -s -k -f --legend
+	@echo "* Coverage report is generated at $(f_debug)/tests/coverage/index.html"
 	@which python || (echo ">>> Please install python"; exit 1)
-	@if [ ! -f build_debug/tests/coverage.info ]; then \
+	@if [ ! -f $(f_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
+	@env python update_coverage.py $(f_debug)/tests

build_conan/CMakeCache.txt

@@ -0,0 +1,101 @@
+# This is the CMakeCache file.
+# For build in directory: /home/rmontanana/Code/mdlp/build_conan
+# It was generated by CMake: /usr/bin/cmake
+# You can edit this file to change values found and used by cmake.
+# If you do not want to change any of the values, simply exit the editor.
+# If you do want to change a value, simply edit, save, and exit the editor.
+# The syntax for the file is as follows:
+# KEY:TYPE=VALUE
+# KEY is the name of a variable in the cache.
+# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!.
+# VALUE is the current value for the KEY.
+
+########################
+# EXTERNAL cache entries
+########################
+
+//No help, variable specified on the command line.
+CMAKE_BUILD_TYPE:UNINITIALIZED=Release
+
+//Value Computed by CMake.
+CMAKE_FIND_PACKAGE_REDIRECTS_DIR:STATIC=/home/rmontanana/Code/mdlp/build_conan/CMakeFiles/pkgRedirects
+
+//Value Computed by CMake
+CMAKE_PROJECT_DESCRIPTION:STATIC=Discretization algorithm based on the paper by Fayyad & Irani Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning.
+
+//Value Computed by CMake
+CMAKE_PROJECT_HOMEPAGE_URL:STATIC=https://github.com/rmontanana/mdlp
+
+//Value Computed by CMake
+CMAKE_PROJECT_NAME:STATIC=fimdlp
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION:STATIC=2.1.0
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_MAJOR:STATIC=2
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_MINOR:STATIC=1
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_PATCH:STATIC=0
+
+//Value Computed by CMake
+CMAKE_PROJECT_VERSION_TWEAK:STATIC=
+
+//No help, variable specified on the command line.
+CMAKE_TOOLCHAIN_FILE:UNINITIALIZED=conan_toolchain.cmake
+
+//Value Computed by CMake
+fimdlp_BINARY_DIR:STATIC=/home/rmontanana/Code/mdlp/build_conan
+
+//Value Computed by CMake
+fimdlp_IS_TOP_LEVEL:STATIC=ON
+
+//Value Computed by CMake
+fimdlp_SOURCE_DIR:STATIC=/home/rmontanana/Code/mdlp
+
+
+########################
+# INTERNAL cache entries
+########################
+
+//This is the directory where this CMakeCache.txt was created
+CMAKE_CACHEFILE_DIR:INTERNAL=/home/rmontanana/Code/mdlp/build_conan
+//Major version of cmake used to create the current loaded cache
+CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3
+//Minor version of cmake used to create the current loaded cache
+CMAKE_CACHE_MINOR_VERSION:INTERNAL=30
+//Patch version of cmake used to create the current loaded cache
+CMAKE_CACHE_PATCH_VERSION:INTERNAL=8
+//Path to CMake executable.
+CMAKE_COMMAND:INTERNAL=/usr/bin/cmake
+//Path to cpack program executable.
+CMAKE_CPACK_COMMAND:INTERNAL=/usr/bin/cpack
+//Path to ctest program executable.
+CMAKE_CTEST_COMMAND:INTERNAL=/usr/bin/ctest
+//Path to cache edit program executable.
+CMAKE_EDIT_COMMAND:INTERNAL=/usr/bin/ccmake
+//Name of external makefile project generator.
+CMAKE_EXTRA_GENERATOR:INTERNAL=
+//Name of generator.
+CMAKE_GENERATOR:INTERNAL=Unix Makefiles
+//Generator instance identifier.
+CMAKE_GENERATOR_INSTANCE:INTERNAL=
+//Name of generator platform.
+CMAKE_GENERATOR_PLATFORM:INTERNAL=
+//Name of generator toolset.
+CMAKE_GENERATOR_TOOLSET:INTERNAL=
+//Source directory with the top level CMakeLists.txt file for this
+// project
+CMAKE_HOME_DIRECTORY:INTERNAL=/home/rmontanana/Code/mdlp
+//number of local generators
+CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=1
+//Platform information initialized
+CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1
+//Path to CMake installation.
+CMAKE_ROOT:INTERNAL=/usr/share/cmake
+//uname command
+CMAKE_UNAME:INTERNAL=/usr/bin/uname
+

conandata.yml

@@ -0,0 +1,16 @@
+sources:
+  "2.1.0":
+    url: "https://github.com/rmontanana/mdlp/archive/refs/tags/v2.1.0.tar.gz"
+    sha256: "placeholder_sha256_hash"
+  "2.0.1":
+    url: "https://github.com/rmontanana/mdlp/archive/refs/tags/v2.0.1.tar.gz"
+    sha256: "placeholder_sha256_hash"
+  "2.0.0":
+    url: "https://github.com/rmontanana/mdlp/archive/refs/tags/v2.0.0.tar.gz"
+    sha256: "placeholder_sha256_hash"
+
+patches:
+  "2.1.0":
+    - patch_file: "patches/001-cmake-fix.patch"
+      patch_description: "Fix CMake configuration for Conan compatibility"
+      patch_type: "portability"

conanfile.py

@@ -1,8 +1,8 @@
-import re
-import os
 from conan import ConanFile
-from conan.tools.cmake import CMake, CMakeToolchain, cmake_layout, CMakeDeps
-from conan.tools.files import save, load
+from conan.tools.cmake import CMakeToolchain, CMake, cmake_layout, CMakeDeps
+from conan.tools.files import copy
+import os
+
 
 class FimdlpConan(ConanFile):
     name = "fimdlp"
@@ -10,10 +10,26 @@ class FimdlpConan(ConanFile):
     license = "MIT"
     author = "Ricardo Montañana <rmontanana@gmail.com>"
     url = "https://github.com/rmontanana/mdlp"
-    description = "Discretization algorithm based on the paper by Fayyad & Irani."
-    topics = ("discretization", "classification", "machine learning")
+    description = "Discretization algorithm based on the paper by Fayyad & Irani Multi-Interval Discretization of Continuous-Valued Attributes for Classification Learning."
+    topics = ("machine-learning", "discretization", "mdlp", "classification")
+    
+    # Package configuration
     settings = "os", "compiler", "build_type", "arch"
-    exports_sources = "src/*", "CMakeLists.txt", "README.md", "config/*", "fimdlpConfig.cmake.in"
+    options = {
+        "shared": [True, False],
+        "fPIC": [True, False],
+        "enable_testing": [True, False],
+        "enable_sample": [True, False],
+    }
+    default_options = {
+        "shared": False,
+        "fPIC": True,
+        "enable_testing": False,
+        "enable_sample": False,
+    }
+    
+    # Sources are located in the same place as this recipe, copy them to the recipe
+    exports_sources = "CMakeLists.txt", "src/*", "sample/*", "tests/*", "config/*", "fimdlpConfig.cmake.in"
 
     def set_version(self):
         # Read the CMakeLists.txt file to get the version
@@ -23,33 +39,73 @@ class FimdlpConan(ConanFile):
             if match:
                 self.version = match.group(1)
         except Exception:
-            self.version = "2.0.1"  # fallback version
-
+            self.version = "0.0.1"  # fallback version
+    
+    def config_options(self):
+        if self.settings.os == "Windows":
+            self.options.rm_safe("fPIC")
+    
+    def configure(self):
+        if self.options.shared:
+            self.options.rm_safe("fPIC")
+    
     def requirements(self):
+        # PyTorch dependency for tensor operations
         self.requires("libtorch/2.7.0")
         
+    def build_requirements(self):
+        self.requires("arff-files/1.2.0") # for tests and sample
+        if self.options.enable_testing: 
+            self.test_requires("gtest/1.16.0")
+    
     def layout(self):
         cmake_layout(self)
-        
+    
     def generate(self):
+        # Generate CMake configuration files
         deps = CMakeDeps(self)
         deps.generate()
+        
         tc = CMakeToolchain(self)
+        # Set CMake variables based on options
+        tc.variables["ENABLE_TESTING"] = self.options.enable_testing
+        tc.variables["ENABLE_SAMPLE"] = self.options.enable_sample
+        tc.variables["BUILD_SHARED_LIBS"] = self.options.shared
         tc.generate()
-
+    
     def build(self):
         cmake = CMake(self)
         cmake.configure()
         cmake.build()
-
+        
+        # Run tests if enabled
+        if self.options.enable_testing:
+            cmake.test()
+    
     def package(self):
+        # Install using CMake
         cmake = CMake(self)
         cmake.install()
-
+        
+        # Copy license file
+        copy(self, "LICENSE", src=self.source_folder, dst=os.path.join(self.package_folder, "licenses"))
+    
     def package_info(self):
+        # Library configuration
         self.cpp_info.libs = ["fimdlp"]
         self.cpp_info.includedirs = ["include"]
-        self.cpp_info.libdirs = ["lib"]
-        self.cpp_info.set_property("cmake_find_mode", "both")
+        
+        # CMake package configuration
+        self.cpp_info.set_property("cmake_file_name", "fimdlp")
         self.cpp_info.set_property("cmake_target_name", "fimdlp::fimdlp")
-        self.cpp_info.set_property("cmake_file_name", "fimdlp")
+        
+        # Compiler features
+        self.cpp_info.cppstd = "17"
+        
+        # System libraries (if needed)
+        if self.settings.os in ["Linux", "FreeBSD"]:
+            self.cpp_info.system_libs.append("m")  # Math library
+            self.cpp_info.system_libs.append("pthread")  # Threading
+        
+        # Build information for consumers
+        self.cpp_info.builddirs = ["lib/cmake/fimdlp"]

sample/CMakeLists.txt

@@ -2,11 +2,15 @@ set(CMAKE_CXX_STANDARD 17)
 
 set(CMAKE_BUILD_TYPE Debug)
 
+find_package(arff-files REQUIRED)
+
 include_directories(
     ${fimdlp_SOURCE_DIR}/src
     ${fimdlp_SOURCE_DIR}/tests/lib/Files
     ${CMAKE_BINARY_DIR}/configured_files/include
+    ${libtorch_INCLUDE_DIRS_RELEASE}
+    ${arff-files_INCLUDE_DIRS}
 )
 
-add_executable(sample sample.cpp )
-target_link_libraries(sample fimdlp "${TORCH_LIBRARIES}")
+add_executable(sample sample.cpp)
+target_link_libraries(sample PRIVATE fimdlp torch::torch arff-files::arff-files)

scripts/build_conan.sh

@@ -0,0 +1,25 @@
+#!/bin/bash
+
+# Build script for fimdlp using Conan
+set -e
+
+echo "Building fimdlp with Conan..."
+
+# Clean previous builds
+rm -rf build_conan
+
+# Install dependencies and build
+conan install . --output-folder=build_conan --build=missing --profile:build=default --profile:host=default
+
+# Build the project
+cd build_conan
+cmake .. -DCMAKE_TOOLCHAIN_FILE=conan_toolchain.cmake -DCMAKE_BUILD_TYPE=Release
+cmake --build .
+
+echo "Build completed successfully!"
+
+# Run tests if requested
+if [ "$1" = "--test" ]; then
+    echo "Running tests..."
+    ctest --output-on-failure
+fi

scripts/create_package.sh

@@ -0,0 +1,33 @@
+#!/bin/bash
+
+# Script to create and upload fimdlp Conan package
+set -e
+
+PACKAGE_NAME="fimdlp"
+PACKAGE_VERSION="2.1.0"
+REMOTE_NAME="cimmeria"
+
+echo "Creating Conan package for $PACKAGE_NAME/$PACKAGE_VERSION..."
+
+# Create the package
+conan create . --profile:build=default --profile:host=default
+
+echo "Package created successfully!"
+
+# Test the package
+echo "Testing package..."
+conan test test_package $PACKAGE_NAME/$PACKAGE_VERSION@ --profile:build=default --profile:host=default
+
+echo "Package tested successfully!"
+
+# Upload to Cimmeria (if remote is configured)
+if conan remote list | grep -q "$REMOTE_NAME"; then
+    echo "Uploading package to $REMOTE_NAME..."
+    conan upload $PACKAGE_NAME/$PACKAGE_VERSION --remote=$REMOTE_NAME --all
+    echo "Package uploaded to $REMOTE_NAME successfully!"
+else
+    echo "Remote '$REMOTE_NAME' not configured. To upload the package:"
+    echo "1. Add the remote: conan remote add $REMOTE_NAME <cimmeria-url>"
+    echo "2. Login: conan remote login $REMOTE_NAME <username>"
+    echo "3. Upload: conan upload $PACKAGE_NAME/$PACKAGE_VERSION --remote=$REMOTE_NAME --all"
+fi

src/BinDisc.cpp

@@ -22,13 +22,15 @@ namespace mdlp {
     BinDisc::~BinDisc() = default;
     void BinDisc::fit(samples_t& X)
     {
-        // y is included for compatibility with the Discretizer interface
-        cutPoints.clear();
+        // Input validation
         if (X.empty()) {
-            cutPoints.push_back(0.0);
-            cutPoints.push_back(0.0);
-            return;
+            throw std::invalid_argument("Input data X cannot be empty");
         }
+        if (X.size() < static_cast<size_t>(n_bins)) {
+            throw std::invalid_argument("Input data size must be at least equal to n_bins");
+        }
+
+        cutPoints.clear();
         if (strategy == strategy_t::QUANTILE) {
             direction = bound_dir_t::RIGHT;
             fit_quantile(X);
@@ -39,10 +41,31 @@ namespace mdlp {
     }
     void BinDisc::fit(samples_t& X, labels_t& y)
     {
+        // Input validation for supervised interface
+        if (X.size() != y.size()) {
+            throw std::invalid_argument("X and y must have the same size");
+        }
+        if (X.empty() || y.empty()) {
+            throw std::invalid_argument("X and y cannot be empty");
+        }
+
+        // BinDisc is inherently unsupervised, but we validate inputs for consistency
+        // Note: y parameter is validated but not used in binning strategy
         fit(X);
     }
     std::vector<precision_t> linspace(precision_t start, precision_t end, int num)
     {
+        // Input validation
+        if (num < 2) {
+            throw std::invalid_argument("Number of points must be at least 2 for linspace");
+        }
+        if (std::isnan(start) || std::isnan(end)) {
+            throw std::invalid_argument("Start and end values cannot be NaN");
+        }
+        if (std::isinf(start) || std::isinf(end)) {
+            throw std::invalid_argument("Start and end values cannot be infinite");
+        }
+
         if (start == end) {
             return { start, end };
         }
@@ -60,6 +83,14 @@ namespace mdlp {
     }
     std::vector<precision_t> percentile(samples_t& data, const std::vector<precision_t>& percentiles)
     {
+        // Input validation
+        if (data.empty()) {
+            throw std::invalid_argument("Data cannot be empty for percentile calculation");
+        }
+        if (percentiles.empty()) {
+            throw std::invalid_argument("Percentiles cannot be empty");
+        }
+
         // Implementation taken from https://dpilger26.github.io/NumCpp/doxygen/html/percentile_8hpp_source.html
         std::vector<precision_t> results;
         bool first = true;

src/CPPFImdlp.cpp

@@ -8,6 +8,7 @@
 #include <algorithm>
 #include <set>
 #include <cmath>
+#include <stdexcept>
 #include "CPPFImdlp.h"
 
 namespace mdlp {
@@ -18,6 +19,17 @@ namespace mdlp {
         max_depth(max_depth_),
         proposed_cuts(proposed)
     {
+        // Input validation for constructor parameters
+        if (min_length_ < 3) {
+            throw std::invalid_argument("min_length must be greater than 2");
+        }
+        if (max_depth_ < 1) {
+            throw std::invalid_argument("max_depth must be greater than 0");
+        }
+        if (proposed < 0.0f) {
+            throw std::invalid_argument("proposed_cuts must be non-negative");
+        }
+        
         direction = bound_dir_t::RIGHT;
     }
 
@@ -49,12 +61,6 @@ namespace mdlp {
         if (X.empty() || y.empty()) {
             throw invalid_argument("X and y must have at least one element");
         }
-        if (min_length < 3) {
-            throw invalid_argument("min_length must be greater than 2");
-        }
-        if (max_depth < 1) {
-            throw invalid_argument("max_depth must be greater than 0");
-        }
         indices = sortIndices(X_, y_);
         metrics.setData(y, indices);
         computeCutPoints(0, X.size(), 1);
@@ -81,26 +87,32 @@ namespace mdlp {
         precision_t previous;
         precision_t actual;
         precision_t next;
-        previous = X[indices[idxPrev]];
-        actual = X[indices[cut]];
-        next = X[indices[idxNext]];
+        previous = safe_X_access(idxPrev);
+        actual = safe_X_access(cut);
+        next = safe_X_access(idxNext);
         // definition 2 of the paper => X[t-1] < X[t]
         // get the first equal value of X in the interval
         while (idxPrev > start && actual == previous) {
-            previous = X[indices[--idxPrev]];
+            --idxPrev;
+            previous = safe_X_access(idxPrev);
         }
         backWall = idxPrev == start && actual == previous;
         // get the last equal value of X in the interval
         while (idxNext < end - 1 && actual == next) {
-            next = X[indices[++idxNext]];
+            ++idxNext;
+            next = safe_X_access(idxNext);
         }
         // # of duplicates before cutpoint
-        n = cut - 1 - idxPrev;
+        n = safe_subtract(safe_subtract(cut, 1), idxPrev);
         // # of duplicates after cutpoint
-        m = idxNext - cut - 1;
+        m = safe_subtract(safe_subtract(idxNext, cut), 1);
         // Decide which values to use
-        cut = cut + (backWall ? m + 1 : -n);
-        actual = X[indices[cut]];
+        if (backWall) {
+            cut = cut + m + 1;
+        } else {
+            cut = safe_subtract(cut, n);
+        }
+        actual = safe_X_access(cut);
         return { (actual + previous) / 2, cut };
     }
 
@@ -109,7 +121,7 @@ namespace mdlp {
         size_t cut;
         pair<precision_t, size_t> result;
         // Check if the interval length and the depth are Ok
-        if (end - start < min_length || depth_ > max_depth)
+        if (end < start || safe_subtract(end, start) < min_length || depth_ > max_depth)
             return;
         depth = depth_ > depth ? depth_ : depth;
         cut = getCandidate(start, end);
@@ -129,14 +141,14 @@ namespace mdlp {
         /* Definition 1: A binary discretization for A is determined by selecting the cut point TA for which
         E(A, TA; S) is minimal amongst all the candidate cut points. */
         size_t candidate = numeric_limits<size_t>::max();
-        size_t elements = end - start;
+        size_t elements = safe_subtract(end, start);
         bool sameValues = true;
         precision_t entropy_left;
         precision_t entropy_right;
         precision_t minEntropy;
         // Check if all the values of the variable in the interval are the same
         for (size_t idx = start + 1; idx < end; idx++) {
-            if (X[indices[idx]] != X[indices[start]]) {
+            if (safe_X_access(idx) != safe_X_access(start)) {
                 sameValues = false;
                 break;
             }
@@ -146,7 +158,7 @@ namespace mdlp {
         minEntropy = metrics.entropy(start, end);
         for (size_t idx = start + 1; idx < end; idx++) {
             // Cutpoints are always on boundaries (definition 2)
-            if (y[indices[idx]] == y[indices[idx - 1]])
+            if (safe_y_access(idx) == safe_y_access(idx - 1))
                 continue;
             entropy_left = precision_t(idx - start) / static_cast<precision_t>(elements) * metrics.entropy(start, idx);
             entropy_right = precision_t(end - idx) / static_cast<precision_t>(elements) * metrics.entropy(idx, end);
@@ -168,7 +180,7 @@ namespace mdlp {
         precision_t ent;
         precision_t ent1;
         precision_t ent2;
-        auto N = precision_t(end - start);
+        auto N = precision_t(safe_subtract(end, start));
         k = metrics.computeNumClasses(start, end);
         k1 = metrics.computeNumClasses(start, cut);
         k2 = metrics.computeNumClasses(cut, end);
@@ -188,6 +200,9 @@ namespace mdlp {
         indices_t idx(X_.size());
         std::iota(idx.begin(), idx.end(), 0);
         stable_sort(idx.begin(), idx.end(), [&X_, &y_](size_t i1, size_t i2) {
+            if (i1 >= X_.size() || i2 >= X_.size() || i1 >= y_.size() || i2 >= y_.size()) {
+                throw std::out_of_range("Index out of bounds in sort comparison");
+            }
             if (X_[i1] == X_[i2])
                 return y_[i1] < y_[i2];
             else
@@ -206,7 +221,7 @@ namespace mdlp {
         size_t end;
         for (size_t idx = 0; idx < cutPoints.size(); idx++) {
             end = begin;
-            while (X[indices[end]] < cutPoints[idx] && end < X.size())
+            while (end < indices.size() && safe_X_access(end) < cutPoints[idx] && end < X.size())
                 end++;
             entropy = metrics.entropy(begin, end);
             if (entropy > maxEntropy) {

src/CPPFImdlp.h

@@ -39,6 +39,33 @@ namespace mdlp {
         size_t getCandidate(size_t, size_t);
         size_t compute_max_num_cut_points() const;
         pair<precision_t, size_t> valueCutPoint(size_t, size_t, size_t);
+    private:
+        inline precision_t safe_X_access(size_t idx) const {
+            if (idx >= indices.size()) {
+                throw std::out_of_range("Index out of bounds for indices array");
+            }
+            size_t real_idx = indices[idx];
+            if (real_idx >= X.size()) {
+                throw std::out_of_range("Index out of bounds for X array");
+            }
+            return X[real_idx];
+        }
+        inline label_t safe_y_access(size_t idx) const {
+            if (idx >= indices.size()) {
+                throw std::out_of_range("Index out of bounds for indices array");
+            }
+            size_t real_idx = indices[idx];
+            if (real_idx >= y.size()) {
+                throw std::out_of_range("Index out of bounds for y array");
+            }
+            return y[real_idx];
+        }
+        inline size_t safe_subtract(size_t a, size_t b) const {
+            if (b > a) {
+                throw std::underflow_error("Subtraction would cause underflow");
+            }
+            return a - b;
+        }
     };
 }
 #endif

src/Discretizer.cpp

@@ -10,6 +10,14 @@ namespace mdlp {
 
     labels_t& Discretizer::transform(const samples_t& data)
     {
+        // Input validation
+        if (data.empty()) {
+            throw std::invalid_argument("Data for transformation cannot be empty");
+        }
+        if (cutPoints.size() < 2) {
+            throw std::runtime_error("Discretizer not fitted yet or no valid cut points found");
+        }
+        
         discretizedData.clear();
         discretizedData.reserve(data.size());
         // CutPoints always have at least two items
@@ -31,6 +39,26 @@ namespace mdlp {
     }
     void Discretizer::fit_t(const torch::Tensor& X_, const torch::Tensor& y_)
     {
+        // Validate tensor properties for security
+        if (!X_.is_contiguous() || !y_.is_contiguous()) {
+            throw std::invalid_argument("Tensors must be contiguous");
+        }
+        if (X_.sizes().size() != 1 || y_.sizes().size() != 1) {
+            throw std::invalid_argument("Only 1D tensors supported");
+        }
+        if (X_.dtype() != torch::kFloat32) {
+            throw std::invalid_argument("X tensor must be Float32 type");
+        }
+        if (y_.dtype() != torch::kInt32) {
+            throw std::invalid_argument("y tensor must be Int32 type");
+        }
+        if (X_.numel() != y_.numel()) {
+            throw std::invalid_argument("X and y tensors must have same number of elements");
+        }
+        if (X_.numel() == 0) {
+            throw std::invalid_argument("Tensors cannot be empty");
+        }
+        
         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);
@@ -38,6 +66,20 @@ namespace mdlp {
     }
     torch::Tensor Discretizer::transform_t(const torch::Tensor& X_)
     {
+        // Validate tensor properties for security
+        if (!X_.is_contiguous()) {
+            throw std::invalid_argument("Tensor must be contiguous");
+        }
+        if (X_.sizes().size() != 1) {
+            throw std::invalid_argument("Only 1D tensors supported");
+        }
+        if (X_.dtype() != torch::kFloat32) {
+            throw std::invalid_argument("X tensor must be Float32 type");
+        }
+        if (X_.numel() == 0) {
+            throw std::invalid_argument("Tensor cannot be empty");
+        }
+        
         auto num_elements = X_.numel();
         samples_t X(X_.data_ptr<precision_t>(), X_.data_ptr<precision_t>() + num_elements);
         auto result = transform(X);
@@ -45,6 +87,26 @@ namespace mdlp {
     }
     torch::Tensor Discretizer::fit_transform_t(const torch::Tensor& X_, const torch::Tensor& y_)
     {
+        // Validate tensor properties for security
+        if (!X_.is_contiguous() || !y_.is_contiguous()) {
+            throw std::invalid_argument("Tensors must be contiguous");
+        }
+        if (X_.sizes().size() != 1 || y_.sizes().size() != 1) {
+            throw std::invalid_argument("Only 1D tensors supported");
+        }
+        if (X_.dtype() != torch::kFloat32) {
+            throw std::invalid_argument("X tensor must be Float32 type");
+        }
+        if (y_.dtype() != torch::kInt32) {
+            throw std::invalid_argument("y tensor must be Int32 type");
+        }
+        if (X_.numel() != y_.numel()) {
+            throw std::invalid_argument("X and y tensors must have same number of elements");
+        }
+        if (X_.numel() == 0) {
+            throw std::invalid_argument("Tensors cannot be empty");
+        }
+        
         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);

src/Metrics.cpp

@@ -26,6 +26,7 @@ namespace mdlp {
 
     void Metrics::setData(const labels_t& y_, const indices_t& indices_)
     {
+        std::lock_guard<std::mutex> lock(cache_mutex);
         indices = indices_;
         y = y_;
         numClasses = computeNumClasses(0, indices.size());
@@ -35,15 +36,23 @@ namespace mdlp {
 
     precision_t Metrics::entropy(size_t start, size_t end)
     {
+        if (end - start < 2)
+            return 0;
+            
+        // Check cache first with read lock
+        {
+            std::lock_guard<std::mutex> lock(cache_mutex);
+            if (entropyCache.find({ start, end }) != entropyCache.end()) {
+                return entropyCache[{start, end}];
+            }
+        }
+        
+        // Compute entropy outside of lock
         precision_t p;
         precision_t ventropy = 0;
         int nElements = 0;
         labels_t counts(numClasses + 1, 0);
-        if (end - start < 2)
-            return 0;
-        if (entropyCache.find({ start, end }) != entropyCache.end()) {
-            return entropyCache[{start, end}];
-        }
+        
         for (auto i = &indices[start]; i != &indices[end]; ++i) {
             counts[y[*i]]++;
             nElements++;
@@ -54,12 +63,27 @@ namespace mdlp {
                 ventropy -= p * log2(p);
             }
         }
-        entropyCache[{start, end}] = ventropy;
+        
+        // Update cache with write lock
+        {
+            std::lock_guard<std::mutex> lock(cache_mutex);
+            entropyCache[{start, end}] = ventropy;
+        }
+        
         return ventropy;
     }
 
     precision_t Metrics::informationGain(size_t start, size_t cut, size_t end)
     {
+        // Check cache first with read lock
+        {
+            std::lock_guard<std::mutex> lock(cache_mutex);
+            if (igCache.find(make_tuple(start, cut, end)) != igCache.end()) {
+                return igCache[make_tuple(start, cut, end)];
+            }
+        }
+        
+        // Compute information gain outside of lock
         precision_t iGain;
         precision_t entropyInterval;
         precision_t entropyLeft;
@@ -67,9 +91,7 @@ namespace mdlp {
         size_t nElementsLeft = cut - start;
         size_t nElementsRight = end - cut;
         size_t nElements = end - start;
-        if (igCache.find(make_tuple(start, cut, end)) != igCache.end()) {
-            return igCache[make_tuple(start, cut, end)];
-        }
+        
         entropyInterval = entropy(start, end);
         entropyLeft = entropy(start, cut);
         entropyRight = entropy(cut, end);
@@ -77,7 +99,13 @@ namespace mdlp {
             (static_cast<precision_t>(nElementsLeft) * entropyLeft +
                 static_cast<precision_t>(nElementsRight) * entropyRight) /
             static_cast<precision_t>(nElements);
-        igCache[make_tuple(start, cut, end)] = iGain;
+            
+        // Update cache with write lock
+        {
+            std::lock_guard<std::mutex> lock(cache_mutex);
+            igCache[make_tuple(start, cut, end)] = iGain;
+        }
+        
         return iGain;
     }
 

src/Metrics.h

@@ -8,6 +8,7 @@
 #define CCMETRICS_H
 
 #include "typesFImdlp.h"
+#include <mutex>
 
 namespace mdlp {
     class Metrics {
@@ -15,6 +16,7 @@ namespace mdlp {
         labels_t& y;
         indices_t& indices;
         int numClasses;
+        mutable std::mutex cache_mutex;
         cacheEnt_t entropyCache = cacheEnt_t();
         cacheIg_t igCache = cacheIg_t();
     public:

test_package/CMakeLists.txt

@@ -0,0 +1,8 @@
+cmake_minimum_required(VERSION 3.20)
+project(test_fimdlp)
+
+find_package(fimdlp REQUIRED)
+
+add_executable(test_fimdlp src/test_fimdlp.cpp)
+target_link_libraries(test_fimdlp fimdlp::fimdlp)
+target_compile_features(test_fimdlp PRIVATE cxx_std_17)

test_package/conanfile.py

@@ -0,0 +1,28 @@
+import os
+from conan import ConanFile
+from conan.tools.cmake import CMake, cmake_layout
+from conan.tools.build import can_run
+
+
+class FimdlpTestConan(ConanFile):
+    settings = "os", "compiler", "build_type", "arch"
+    # VirtualBuildEnv and VirtualRunEnv can be avoided if "tools.env:CONAN_RUN_TESTS" is false
+    generators = "CMakeDeps", "CMakeToolchain", "VirtualRunEnv"
+    apply_env = False  # avoid the default VirtualBuildEnv from the base class
+    test_type = "explicit"
+
+    def requirements(self):
+        self.requires(self.tested_reference_str)
+
+    def layout(self):
+        cmake_layout(self)
+
+    def build(self):
+        cmake = CMake(self)
+        cmake.configure()
+        cmake.build()
+
+    def test(self):
+        if can_run(self):
+            cmd = os.path.join(self.cpp.build.bindir, "test_fimdlp")
+            self.run(cmd, env="conanrun")

test_package/src/test_fimdlp.cpp

@@ -0,0 +1,27 @@
+#include <iostream>
+#include <vector>
+#include <fimdlp/CPPFImdlp.h>
+#include <fimdlp/Metrics.h>
+
+int main() {
+    std::cout << "Testing fimdlp library..." << std::endl;
+    
+    // Simple test of the library
+    try {
+        // Test Metrics class
+        Metrics metrics;
+        std::vector<int> labels = {0, 0, 1, 1, 0, 1};
+        double entropy = metrics.entropy(labels);
+        std::cout << "Entropy calculated: " << entropy << std::endl;
+        
+        // Test CPPFImdlp creation
+        CPPFImdlp discretizer;
+        std::cout << "CPPFImdlp instance created successfully" << std::endl;
+        
+        std::cout << "fimdlp library test completed successfully!" << std::endl;
+        return 0;
+    } catch (const std::exception& e) {
+        std::cerr << "Error testing fimdlp library: " << e.what() << std::endl;
+        return 1;
+    }
+}

tests/BinDisc_unittest.cpp

@@ -16,13 +16,13 @@ namespace mdlp {
     const float margin = 1e-4;
     static std::string set_data_path()
     {
-        std::string path = "../datasets/";
+        std::string path = "datasets/";
         std::ifstream file(path + "iris.arff");
         if (file.is_open()) {
             file.close();
             return path;
         }
-        return "../../tests/datasets/";
+        return "tests/datasets/";
     }
     const std::string data_path = set_data_path();
     class TestBinDisc3U : public BinDisc, public testing::Test {

tests/CMakeLists.txt

@@ -1,17 +1,11 @@
-include(FetchContent)
-include_directories(${GTEST_INCLUDE_DIRS})
-FetchContent_Declare(
-        googletest
-        URL https://github.com/google/googletest/archive/03597a01ee50ed33e9dfd640b249b4be3799d395.zip
-)
-# For Windows: Prevent overriding the parent project's compiler/linker settings
-set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
-FetchContent_MakeAvailable(googletest)
+
+find_package(arff-files REQUIRED)
+find_package(GTest REQUIRED)
 
 include_directories(
-        ${TORCH_INCLUDE_DIRS}
+        ${libtorch_INCLUDE_DIRS_DEBUG}
         ${fimdlp_SOURCE_DIR}/src
-        ${fimdlp_SOURCE_DIR}/tests/lib/Files    
+        ${arff-files_INCLUDE_DIRS}
         ${CMAKE_BINARY_DIR}/configured_files/include
 )
 
@@ -22,18 +16,18 @@ target_link_options(Metrics_unittest PRIVATE --coverage)
 
 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_link_libraries(FImdlp_unittest GTest::gtest_main torch::torch)
 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)
-target_link_libraries(BinDisc_unittest GTest::gtest_main "${TORCH_LIBRARIES}")
+target_link_libraries(BinDisc_unittest GTest::gtest_main torch::torch)
 target_compile_options(BinDisc_unittest PRIVATE --coverage)
 target_link_options(BinDisc_unittest PRIVATE --coverage)
 
 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_link_libraries(Discretizer_unittest GTest::gtest_main torch::torch)
 target_compile_options(Discretizer_unittest PRIVATE --coverage)
 target_link_options(Discretizer_unittest PRIVATE --coverage)
 

tests/Discretizer_unittest.cpp

@@ -17,13 +17,13 @@ namespace mdlp {
     const float margin = 1e-4;
     static std::string set_data_path()
     {
-        std::string path = "../datasets/";
+        std::string path = "datasets/";
         std::ifstream file(path + "iris.arff");
         if (file.is_open()) {
             file.close();
             return path;
         }
-        return "../../tests/datasets/";
+        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 };
@@ -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("2.1.0", version);
     }
     TEST(Discretizer, BinIrisUniform)
     {

tests/FImdlp_unittest.cpp

@@ -40,13 +40,13 @@ namespace mdlp {
 
         static string set_data_path()
         {
-            string path = "../datasets/";
+            string path = "datasets/";
             ifstream file(path + "iris.arff");
             if (file.is_open()) {
                 file.close();
                 return path;
             }
-            return "../../tests/datasets/";
+            return "tests/datasets/";
         }
 
         void checkSortedVector()