Merge pull request 'Exchange OpenXLSX to libxlsxwriter' (#8 ) from libxlsxwriter into main

Add multiple sheets to excel file Add format and color to sheets Add comparison with ZeroR Add comparison with Best Results Separate contextual menu from general in manage
Separate contextual menu from general
2023-09-20 11:17:16 +00:00 · 2023-09-20 13:15:33 +02:00 · 2023-09-20 12:51:19 +02:00 · 2023-09-20 11:40:01 +02:00 · 2023-09-20 10:30:45 +02:00 · 2023-09-20 01:09:58 +02:00
31 changed files with 893 additions and 395 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -36,3 +36,4 @@ build/
 cmake-build*/**
 .idea
 puml/**
+.vscode/settings.json
--- a/.gitmodules
+++ b/.gitmodules
@@ -10,6 +10,6 @@
 [submodule "lib/json"]
 	path = lib/json
 	url = https://github.com/nlohmann/json.git
-[submodule "lib/openXLSX"]
-	path = lib/openXLSX
-	url = https://github.com/troldal/OpenXLSX.git
+[submodule "lib/libxlsxwriter"]
+	path = lib/libxlsxwriter
+	url = https://github.com/jmcnamara/libxlsxwriter.git
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -25,9 +25,9 @@
            "program": "${workspaceFolder}/build/src/Platform/main",
            "args": [
                "-m",
-                "AODE",
+                "BoostAODE",
                "-p",
-                "/home/rmontanana/Code/discretizbench/datasets",
+                "/Users/rmontanana/Code/discretizbench/datasets",
                "--stratified",
                "-d",
                "mfeat-morphological",
@@ -35,7 +35,7 @@
                // "--hyperparameters",
                // "{\"repeatSparent\": true, \"maxModels\": 12}"
            ],
-            "cwd": "/home/rmontanana/Code/discretizbench",
+            "cwd": "/Users/rmontanana/Code/discretizbench",
        },
        {
            "type": "lldb",
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,109 +0,0 @@
-{
-    "files.associations": {
-        "*.rmd": "markdown",
-        "*.py": "python",
-        "vector": "cpp",
-        "__bit_reference": "cpp",
-        "__bits": "cpp",
-        "__config": "cpp",
-        "__debug": "cpp",
-        "__errc": "cpp",
-        "__hash_table": "cpp",
-        "__locale": "cpp",
-        "__mutex_base": "cpp",
-        "__node_handle": "cpp",
-        "__nullptr": "cpp",
-        "__split_buffer": "cpp",
-        "__string": "cpp",
-        "__threading_support": "cpp",
-        "__tuple": "cpp",
-        "array": "cpp",
-        "atomic": "cpp",
-        "bitset": "cpp",
-        "cctype": "cpp",
-        "chrono": "cpp",
-        "clocale": "cpp",
-        "cmath": "cpp",
-        "compare": "cpp",
-        "complex": "cpp",
-        "concepts": "cpp",
-        "cstdarg": "cpp",
-        "cstddef": "cpp",
-        "cstdint": "cpp",
-        "cstdio": "cpp",
-        "cstdlib": "cpp",
-        "cstring": "cpp",
-        "ctime": "cpp",
-        "cwchar": "cpp",
-        "cwctype": "cpp",
-        "exception": "cpp",
-        "initializer_list": "cpp",
-        "ios": "cpp",
-        "iosfwd": "cpp",
-        "istream": "cpp",
-        "limits": "cpp",
-        "locale": "cpp",
-        "memory": "cpp",
-        "mutex": "cpp",
-        "new": "cpp",
-        "optional": "cpp",
-        "ostream": "cpp",
-        "ratio": "cpp",
-        "sstream": "cpp",
-        "stdexcept": "cpp",
-        "streambuf": "cpp",
-        "string": "cpp",
-        "string_view": "cpp",
-        "system_error": "cpp",
-        "tuple": "cpp",
-        "type_traits": "cpp",
-        "typeinfo": "cpp",
-        "unordered_map": "cpp",
-        "variant": "cpp",
-        "algorithm": "cpp",
-        "iostream": "cpp",
-        "iomanip": "cpp",
-        "numeric": "cpp",
-        "set": "cpp",
-        "__tree": "cpp",
-        "deque": "cpp",
-        "list": "cpp",
-        "map": "cpp",
-        "unordered_set": "cpp",
-        "any": "cpp",
-        "condition_variable": "cpp",
-        "forward_list": "cpp",
-        "fstream": "cpp",
-        "stack": "cpp",
-        "thread": "cpp",
-        "__memory": "cpp",
-        "filesystem": "cpp",
-        "*.toml": "toml",
-        "utility": "cpp",
-        "__verbose_abort": "cpp",
-        "bit": "cpp",
-        "random": "cpp",
-        "*.tcc": "cpp",
-        "functional": "cpp",
-        "iterator": "cpp",
-        "memory_resource": "cpp",
-        "format": "cpp",
-        "valarray": "cpp",
-        "regex": "cpp",
-        "span": "cpp",
-        "cfenv": "cpp",
-        "cinttypes": "cpp",
-        "csetjmp": "cpp",
-        "future": "cpp",
-        "queue": "cpp",
-        "typeindex": "cpp",
-        "shared_mutex": "cpp",
-        "*.ipp": "cpp",
-        "cassert": "cpp",
-        "charconv": "cpp",
-        "source_location": "cpp",
-        "ranges": "cpp"
-    },
-    "cmake.configureOnOpen": false,
-    "C_Cpp.default.configurationProvider": "ms-vscode.cmake-tools"
-}
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -40,7 +40,7 @@ if (CODE_COVERAGE)
    enable_testing()
    include(CodeCoverage)
    MESSAGE("Code coverage enabled")
-    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0")
+    set(CMAKE_CXX_FLAGS " ${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage -O0 -g")
    SET(GCC_COVERAGE_LINK_FLAGS " ${GCC_COVERAGE_LINK_FLAGS} -lgcov --coverage")
 endif (CODE_COVERAGE)

@@ -54,7 +54,6 @@ endif (ENABLE_CLANG_TIDY)
 add_git_submodule("lib/mdlp")
 add_git_submodule("lib/argparse")
 add_git_submodule("lib/json")
-add_git_submodule("lib/openXLSX")

 # Subdirectories
 # --------------
@@ -74,7 +73,6 @@ file(GLOB Platform_SOURCES CONFIGURE_DEPENDS ${BayesNet_SOURCE_DIR}/src/Platform
 if (ENABLE_TESTING)
  MESSAGE("Testing enabled")
  add_git_submodule("lib/catch2")  
-  
  include(CTest)
  add_subdirectory(tests)
 endif (ENABLE_TESTING)
--- a/2
+++ b/2
@@ -40,7 +40,7 @@ debug: ## Build a debug version of the project
 	@if [ -d ./build ]; then rm -rf ./build; fi
 	@mkdir build; 
 	cmake -S . -B build -D CMAKE_BUILD_TYPE=Debug -D ENABLE_TESTING=ON -D CODE_COVERAGE=ON; \
-	cmake --build build -j 32;
+	cmake --build build -t main -t BayesNetSample -t manage -t list  unit_tests -j 32;
 	@echo ">>> Done";

 release: ## Build a Release version of the project
--- a/README.md
+++ b/README.md
@@ -2,4 +2,36 @@

 Bayesian Network Classifier with libtorch from scratch

+## 0. Setup
+
+### libxlswriter
+
+Before compiling BayesNet.
+
+```bash
+cd lib/libxlsxwriter
+make
+sudo make install
+```
+
+It has to be installed in /usr/local/lib otherwise CMakeLists.txt has to be modified accordingly
+
+Environment variable has to be set:
+
+```bash
+ export LD_LIBRARY_PATH=/usr/local/lib
+ ```
+
+### Release
+
+```bash
+make release
+```
+
+### Debug & Tests
+
+```bash
+make debug
+```
+
 ## 1. Introduction
--- a/lib/catch2
+++ b/lib/catch2
--- a/lib/libxlsxwriter
+++ b/lib/libxlsxwriter
--- a/lib/openXLSX
+++ b/lib/openXLSX
--- a/sample/sample.cc
+++ b/sample/sample.cc
@@ -58,180 +58,226 @@ pair<vector<vector<int>>, vector<int>> extract_indices(vector<int> indices, vect

 int main(int argc, char** argv)
 {
-    map<string, bool> datasets = {
-            {"diabetes",           true},
-            {"ecoli",              true},
-            {"glass",              true},
-            {"iris",               true},
-            {"kdd_JapaneseVowels", false},
-            {"letter",             true},
-            {"liver-disorders",    true},
-            {"mfeat-factors",      true},
-    };
-    auto valid_datasets = vector<string>();
-    transform(datasets.begin(), datasets.end(), back_inserter(valid_datasets),
-        [](const pair<string, bool>& pair) { return pair.first; });
-    argparse::ArgumentParser program("BayesNetSample");
-    program.add_argument("-d", "--dataset")
-        .help("Dataset file name")
-        .action([valid_datasets](const std::string& value) {
-        if (find(valid_datasets.begin(), valid_datasets.end(), value) != valid_datasets.end()) {
-            return value;
-        }
-        throw runtime_error("file must be one of {diabetes, ecoli, glass, iris, kdd_JapaneseVowels, letter, liver-disorders, mfeat-factors}");
-            }
-    );
-    program.add_argument("-p", "--path")
-        .help(" folder where the data files are located, default")
-        .default_value(string{ PATH }
-    );
-    program.add_argument("-m", "--model")
-        .help("Model to use " + platform::Models::instance()->toString())
-        .action([](const std::string& value) {
-        static const vector<string> choices = platform::Models::instance()->getNames();
-        if (find(choices.begin(), choices.end(), value) != choices.end()) {
-            return value;
-        }
-        throw runtime_error("Model must be one of " + platform::Models::instance()->toString());
-            }
-    );
-    program.add_argument("--discretize").help("Discretize input dataset").default_value(false).implicit_value(true);
-    program.add_argument("--dumpcpt").help("Dump CPT Tables").default_value(false).implicit_value(true);
-    program.add_argument("--stratified").help("If Stratified KFold is to be done").default_value(false).implicit_value(true);
-    program.add_argument("--tensors").help("Use tensors to store samples").default_value(false).implicit_value(true);
-    program.add_argument("-f", "--folds").help("Number of folds").default_value(5).scan<'i', int>().action([](const string& value) {
-        try {
-            auto k = stoi(value);
-            if (k < 2) {
-                throw runtime_error("Number of folds must be greater than 1");
-            }
-            return k;
-        }
-        catch (const runtime_error& err) {
-            throw runtime_error(err.what());
-        }
-        catch (...) {
-            throw runtime_error("Number of folds must be an integer");
-        }});
-    program.add_argument("-s", "--seed").help("Random seed").default_value(-1).scan<'i', int>();
-    bool class_last, stratified, tensors, dump_cpt;
-    string model_name, file_name, path, complete_file_name;
-    int nFolds, seed;
-    try {
-        program.parse_args(argc, argv);
-        file_name = program.get<string>("dataset");
-        path = program.get<string>("path");
-        model_name = program.get<string>("model");
-        complete_file_name = path + file_name + ".arff";
-        stratified = program.get<bool>("stratified");
-        tensors = program.get<bool>("tensors");
-        nFolds = program.get<int>("folds");
-        seed = program.get<int>("seed");
-        dump_cpt = program.get<bool>("dumpcpt");
-        class_last = datasets[file_name];
-        if (!file_exists(complete_file_name)) {
-            throw runtime_error("Data File " + path + file_name + ".arff" + " does not exist");
-        }
+    torch::Tensor weights_ = torch::full({ 10 }, 1.0 / 10, torch::kFloat64);
+    torch::Tensor y_ = torch::tensor({ 1, 1, 1, 1, 1, 0, 0, 0, 0, 0 }, torch::kInt32);
+    torch::Tensor ypred = torch::tensor({ 1, 1, 1, 0, 0, 1, 1, 1, 1, 0 }, torch::kInt32);
+    cout << "Initial weights_: " << endl;
+    for (int i = 0; i < 10; i++) {
+        cout << weights_.index({ i }).item<double>() << ", ";
    }
-    catch (const exception& err) {
-        cerr << err.what() << endl;
-        cerr << program;
-        exit(1);
+    cout << "end." << endl;
+    cout << "y_: " << endl;
+    for (int i = 0; i < 10; i++) {
+        cout << y_.index({ i }).item<int>() << ", ";
    }
+    cout << "end." << endl;
+    cout << "ypred: " << endl;
+    for (int i = 0; i < 10; i++) {
+        cout << ypred.index({ i }).item<int>() << ", ";
+    }
+    cout << "end." << endl;
+    auto mask_wrong = ypred != y_;
+    auto mask_right = ypred == y_;
+    auto masked_weights = weights_ * mask_wrong.to(weights_.dtype());
+    double epsilon_t = masked_weights.sum().item<double>();
+    cout << "epsilon_t: " << epsilon_t << endl;
+    double wt = (1 - epsilon_t) / epsilon_t;
+    cout << "wt: " << wt << endl;
+    double alpha_t = epsilon_t == 0 ? 1 : 0.5 * log(wt);
+    cout << "alpha_t: " << alpha_t << endl;
+    // Step 3.2: Update weights for next classifier
+    // Step 3.2.1: Update weights of wrong samples
+    cout << "exp(alpha_t): " << exp(alpha_t) << endl;
+    cout << "exp(-alpha_t): " << exp(-alpha_t) << endl;
+    weights_ += mask_wrong.to(weights_.dtype()) * exp(alpha_t) * weights_;
+    // Step 3.2.2: Update weights of right samples
+    weights_ += mask_right.to(weights_.dtype()) * exp(-alpha_t) * weights_;
+    // Step 3.3: Normalise the weights
+    double totalWeights = torch::sum(weights_).item<double>();
+    cout << "totalWeights: " << totalWeights << endl;
+    cout << "Before normalization: " << endl;
+    for (int i = 0; i < 10; i++) {
+        cout << weights_.index({ i }).item<double>() << endl;
+    }
+    weights_ = weights_ / totalWeights;
+    cout << "After normalization: " << endl;
+    for (int i = 0; i < 10; i++) {
+        cout << weights_.index({ i }).item<double>() << endl;
+    }
+    // map<string, bool> datasets = {
+    //         {"diabetes",           true},
+    //         {"ecoli",              true},
+    //         {"glass",              true},
+    //         {"iris",               true},
+    //         {"kdd_JapaneseVowels", false},
+    //         {"letter",             true},
+    //         {"liver-disorders",    true},
+    //         {"mfeat-factors",      true},
+    // };
+    // auto valid_datasets = vector<string>();
+    // transform(datasets.begin(), datasets.end(), back_inserter(valid_datasets),
+    //     [](const pair<string, bool>& pair) { return pair.first; });
+    // argparse::ArgumentParser program("BayesNetSample");
+    // program.add_argument("-d", "--dataset")
+    //     .help("Dataset file name")
+    //     .action([valid_datasets](const std::string& value) {
+    //     if (find(valid_datasets.begin(), valid_datasets.end(), value) != valid_datasets.end()) {
+    //         return value;
+    //     }
+    //     throw runtime_error("file must be one of {diabetes, ecoli, glass, iris, kdd_JapaneseVowels, letter, liver-disorders, mfeat-factors}");
+    //         }
+    // );
+    // program.add_argument("-p", "--path")
+    //     .help(" folder where the data files are located, default")
+    //     .default_value(string{ PATH }
+    // );
+    // program.add_argument("-m", "--model")
+    //     .help("Model to use " + platform::Models::instance()->toString())
+    //     .action([](const std::string& value) {
+    //     static const vector<string> choices = platform::Models::instance()->getNames();
+    //     if (find(choices.begin(), choices.end(), value) != choices.end()) {
+    //         return value;
+    //     }
+    //     throw runtime_error("Model must be one of " + platform::Models::instance()->toString());
+    //         }
+    // );
+    // program.add_argument("--discretize").help("Discretize input dataset").default_value(false).implicit_value(true);
+    // program.add_argument("--dumpcpt").help("Dump CPT Tables").default_value(false).implicit_value(true);
+    // program.add_argument("--stratified").help("If Stratified KFold is to be done").default_value(false).implicit_value(true);
+    // program.add_argument("--tensors").help("Use tensors to store samples").default_value(false).implicit_value(true);
+    // program.add_argument("-f", "--folds").help("Number of folds").default_value(5).scan<'i', int>().action([](const string& value) {
+    //     try {
+    //         auto k = stoi(value);
+    //         if (k < 2) {
+    //             throw runtime_error("Number of folds must be greater than 1");
+    //         }
+    //         return k;
+    //     }
+    //     catch (const runtime_error& err) {
+    //         throw runtime_error(err.what());
+    //     }
+    //     catch (...) {
+    //         throw runtime_error("Number of folds must be an integer");
+    //     }});
+    // program.add_argument("-s", "--seed").help("Random seed").default_value(-1).scan<'i', int>();
+    // bool class_last, stratified, tensors, dump_cpt;
+    // string model_name, file_name, path, complete_file_name;
+    // int nFolds, seed;
+    // try {
+    //     program.parse_args(argc, argv);
+    //     file_name = program.get<string>("dataset");
+    //     path = program.get<string>("path");
+    //     model_name = program.get<string>("model");
+    //     complete_file_name = path + file_name + ".arff";
+    //     stratified = program.get<bool>("stratified");
+    //     tensors = program.get<bool>("tensors");
+    //     nFolds = program.get<int>("folds");
+    //     seed = program.get<int>("seed");
+    //     dump_cpt = program.get<bool>("dumpcpt");
+    //     class_last = datasets[file_name];
+    //     if (!file_exists(complete_file_name)) {
+    //         throw runtime_error("Data File " + path + file_name + ".arff" + " does not exist");
+    //     }
+    // }
+    // catch (const exception& err) {
+    //     cerr << err.what() << endl;
+    //     cerr << program;
+    //     exit(1);
+    // }

    /*
    * Begin Processing
    */
-    auto handler = ArffFiles();
-    handler.load(complete_file_name, class_last);
-    // Get Dataset X, y
-    vector<mdlp::samples_t>& X = handler.getX();
-    mdlp::labels_t& y = handler.getY();
-    // Get className & Features
-    auto className = handler.getClassName();
-    vector<string> features;
-    auto attributes = handler.getAttributes();
-    transform(attributes.begin(), attributes.end(), back_inserter(features),
-        [](const pair<string, string>& item) { return item.first; });
-    // Discretize Dataset
-    auto [Xd, maxes] = discretize(X, y, features);
-    maxes[className] = *max_element(y.begin(), y.end()) + 1;
-    map<string, vector<int>> states;
-    for (auto feature : features) {
-        states[feature] = vector<int>(maxes[feature]);
-    }
-    states[className] = vector<int>(maxes[className]);
-    auto clf = platform::Models::instance()->create(model_name);
-    clf->fit(Xd, y, features, className, states);
-    if (dump_cpt) {
-        cout << "--- CPT Tables ---" << endl;
-        clf->dump_cpt();
-    }
-    auto lines = clf->show();
-    for (auto line : lines) {
-        cout << line << endl;
-    }
-    cout << "--- Topological Order ---" << endl;
-    auto order = clf->topological_order();
-    for (auto name : order) {
-        cout << name << ", ";
-    }
-    cout << "end." << endl;
-    auto score = clf->score(Xd, y);
-    cout << "Score: " << score << endl;
-    auto graph = clf->graph();
-    auto dot_file = model_name + "_" + file_name;
-    ofstream file(dot_file + ".dot");
-    file << graph;
-    file.close();
-    cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
-    cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
-    string stratified_string = stratified ? " Stratified" : "";
-    cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
-    cout << "==========================================" << endl;
-    torch::Tensor Xt = torch::zeros({ static_cast<int>(Xd.size()), static_cast<int>(Xd[0].size()) }, torch::kInt32);
-    torch::Tensor yt = torch::tensor(y, torch::kInt32);
-    for (int i = 0; i < features.size(); ++i) {
-        Xt.index_put_({ i, "..." }, torch::tensor(Xd[i], torch::kInt32));
-    }
-    float total_score = 0, total_score_train = 0, score_train, score_test;
-    platform::Fold* fold;
-    if (stratified)
-        fold = new platform::StratifiedKFold(nFolds, y, seed);
-    else
-        fold = new platform::KFold(nFolds, y.size(), seed);
-    for (auto i = 0; i < nFolds; ++i) {
-        auto [train, test] = fold->getFold(i);
-        cout << "Fold: " << i + 1 << endl;
-        if (tensors) {
-            auto ttrain = torch::tensor(train, torch::kInt64);
-            auto ttest = torch::tensor(test, torch::kInt64);
-            torch::Tensor Xtraint = torch::index_select(Xt, 1, ttrain);
-            torch::Tensor ytraint = yt.index({ ttrain });
-            torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
-            torch::Tensor ytestt = yt.index({ ttest });
-            clf->fit(Xtraint, ytraint, features, className, states);
-            auto temp = clf->predict(Xtraint);
-            score_train = clf->score(Xtraint, ytraint);
-            score_test = clf->score(Xtestt, ytestt);
-        } else {
-            auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
-            auto [Xtest, ytest] = extract_indices(test, Xd, y);
-            clf->fit(Xtrain, ytrain, features, className, states);
-            score_train = clf->score(Xtrain, ytrain);
-            score_test = clf->score(Xtest, ytest);
-        }
-        if (dump_cpt) {
-            cout << "--- CPT Tables ---" << endl;
-            clf->dump_cpt();
-        }
-        total_score_train += score_train;
-        total_score += score_test;
-        cout << "Score Train: " << score_train << endl;
-        cout << "Score Test : " << score_test << endl;
-        cout << "-------------------------------------------------------------------------------" << endl;
-    }
-    cout << "**********************************************************************************" << endl;
-    cout << "Average Score Train: " << total_score_train / nFolds << endl;
-    cout << "Average Score Test : " << total_score / nFolds << endl;return 0;
+    // auto handler = ArffFiles();
+    // handler.load(complete_file_name, class_last);
+    // // Get Dataset X, y
+    // vector<mdlp::samples_t>& X = handler.getX();
+    // mdlp::labels_t& y = handler.getY();
+    // // Get className & Features
+    // auto className = handler.getClassName();
+    // vector<string> features;
+    // auto attributes = handler.getAttributes();
+    // transform(attributes.begin(), attributes.end(), back_inserter(features),
+    //     [](const pair<string, string>& item) { return item.first; });
+    // // Discretize Dataset
+    // auto [Xd, maxes] = discretize(X, y, features);
+    // maxes[className] = *max_element(y.begin(), y.end()) + 1;
+    // map<string, vector<int>> states;
+    // for (auto feature : features) {
+    //     states[feature] = vector<int>(maxes[feature]);
+    // }
+    // states[className] = vector<int>(maxes[className]);
+    // auto clf = platform::Models::instance()->create(model_name);
+    // clf->fit(Xd, y, features, className, states);
+    // if (dump_cpt) {
+    //     cout << "--- CPT Tables ---" << endl;
+    //     clf->dump_cpt();
+    // }
+    // auto lines = clf->show();
+    // for (auto line : lines) {
+    //     cout << line << endl;
+    // }
+    // cout << "--- Topological Order ---" << endl;
+    // auto order = clf->topological_order();
+    // for (auto name : order) {
+    //     cout << name << ", ";
+    // }
+    // cout << "end." << endl;
+    // auto score = clf->score(Xd, y);
+    // cout << "Score: " << score << endl;
+    // auto graph = clf->graph();
+    // auto dot_file = model_name + "_" + file_name;
+    // ofstream file(dot_file + ".dot");
+    // file << graph;
+    // file.close();
+    // cout << "Graph saved in " << model_name << "_" << file_name << ".dot" << endl;
+    // cout << "dot -Tpng -o " + dot_file + ".png " + dot_file + ".dot " << endl;
+    // string stratified_string = stratified ? " Stratified" : "";
+    // cout << nFolds << " Folds" << stratified_string << " Cross validation" << endl;
+    // cout << "==========================================" << endl;
+    // torch::Tensor Xt = torch::zeros({ static_cast<int>(Xd.size()), static_cast<int>(Xd[0].size()) }, torch::kInt32);
+    // torch::Tensor yt = torch::tensor(y, torch::kInt32);
+    // for (int i = 0; i < features.size(); ++i) {
+    //     Xt.index_put_({ i, "..." }, torch::tensor(Xd[i], torch::kInt32));
+    // }
+    // float total_score = 0, total_score_train = 0, score_train, score_test;
+    // platform::Fold* fold;
+    // if (stratified)
+    //     fold = new platform::StratifiedKFold(nFolds, y, seed);
+    // else
+    //     fold = new platform::KFold(nFolds, y.size(), seed);
+    // for (auto i = 0; i < nFolds; ++i) {
+    //     auto [train, test] = fold->getFold(i);
+    //     cout << "Fold: " << i + 1 << endl;
+    //     if (tensors) {
+    //         auto ttrain = torch::tensor(train, torch::kInt64);
+    //         auto ttest = torch::tensor(test, torch::kInt64);
+    //         torch::Tensor Xtraint = torch::index_select(Xt, 1, ttrain);
+    //         torch::Tensor ytraint = yt.index({ ttrain });
+    //         torch::Tensor Xtestt = torch::index_select(Xt, 1, ttest);
+    //         torch::Tensor ytestt = yt.index({ ttest });
+    //         clf->fit(Xtraint, ytraint, features, className, states);
+    //         auto temp = clf->predict(Xtraint);
+    //         score_train = clf->score(Xtraint, ytraint);
+    //         score_test = clf->score(Xtestt, ytestt);
+    //     } else {
+    //         auto [Xtrain, ytrain] = extract_indices(train, Xd, y);
+    //         auto [Xtest, ytest] = extract_indices(test, Xd, y);
+    //         clf->fit(Xtrain, ytrain, features, className, states);
+    //         score_train = clf->score(Xtrain, ytrain);
+    //         score_test = clf->score(Xtest, ytest);
+    //     }
+    //     if (dump_cpt) {
+    //         cout << "--- CPT Tables ---" << endl;
+    //         clf->dump_cpt();
+    //     }
+    //     total_score_train += score_train;
+    //     total_score += score_test;
+    //     cout << "Score Train: " << score_train << endl;
+    //     cout << "Score Test : " << score_test << endl;
+    //     cout << "-------------------------------------------------------------------------------" << endl;
+    // }
+    // cout << "**********************************************************************************" << endl;
+    // cout << "Average Score Train: " << total_score_train / nFolds << endl;
+    // cout << "Average Score Test : " << total_score / nFolds << endl;return 0;
 }
--- a/src/BayesNet/BaseClassifier.h
+++ b/src/BayesNet/BaseClassifier.h
@@ -5,6 +5,7 @@
 #include <vector>
 namespace bayesnet {
    using namespace std;
+    enum status_t { NORMAL, WARNING, ERROR };
    class BaseClassifier {
    protected:
        virtual void trainModel(const torch::Tensor& weights) = 0;
@@ -18,6 +19,7 @@ namespace bayesnet {
        virtual ~BaseClassifier() = default;
        torch::Tensor virtual predict(torch::Tensor& X) = 0;
        vector<int> virtual predict(vector<vector<int>>& X) = 0;
+        status_t virtual getStatus() const = 0;
        float virtual score(vector<vector<int>>& X, vector<int>& y) = 0;
        float virtual score(torch::Tensor& X, torch::Tensor& y) = 0;
        int virtual getNumberOfNodes()const = 0;
--- a/src/BayesNet/BoostAODE.cc
+++ b/src/BayesNet/BoostAODE.cc
@@ -1,6 +1,9 @@
 #include "BoostAODE.h"
 #include <set>
 #include "BayesMetrics.h"
+#include "Colors.h"
+#include "Folding.h"
+#include <limits.h>

 namespace bayesnet {
    BoostAODE::BoostAODE() : Ensemble() {}
@@ -11,7 +14,7 @@ namespace bayesnet {
    void BoostAODE::setHyperparameters(nlohmann::json& hyperparameters)
    {
        // Check if hyperparameters are valid
-        const vector<string> validKeys = { "repeatSparent", "maxModels", "ascending" };
+        const vector<string> validKeys = { "repeatSparent", "maxModels", "ascending", "convergence" };
        checkHyperparameters(validKeys, hyperparameters);
        if (hyperparameters.contains("repeatSparent")) {
            repeatSparent = hyperparameters["repeatSparent"];
@@ -22,6 +25,38 @@ namespace bayesnet {
        if (hyperparameters.contains("ascending")) {
            ascending = hyperparameters["ascending"];
        }
+        if (hyperparameters.contains("convergence")) {
+            convergence = hyperparameters["convergence"];
+        }
+    }
+    void BoostAODE::validationInit()
+    {
+        auto y_ = dataset.index({ -1, "..." });
+        if (convergence) {
+            // Prepare train & validation sets from train data
+            auto fold = platform::StratifiedKFold(5, y_, 271);
+            dataset_ = torch::clone(dataset);
+            // save input dataset
+            auto [train, test] = fold.getFold(0);
+            auto train_t = torch::tensor(train);
+            auto test_t = torch::tensor(test);
+            // Get train and validation sets
+            X_train = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), train_t });
+            y_train = dataset.index({ -1, train_t });
+            X_test = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), test_t });
+            y_test = dataset.index({ -1, test_t });
+            dataset = X_train;
+            m = X_train.size(1);
+            auto n_classes = states.at(className).size();
+            metrics = Metrics(dataset, features, className, n_classes);
+            // Build dataset with train data
+            buildDataset(y_train);
+        } else {
+            // Use all data to train
+            X_train = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." });
+            y_train = y_;
+        }
+
    }
    void BoostAODE::trainModel(const torch::Tensor& weights)
    {
@@ -29,14 +64,22 @@ namespace bayesnet {
        n_models = 0;
        if (maxModels == 0)
            maxModels = .1 * n > 10 ? .1 * n : n;
+        validationInit();
        Tensor weights_ = torch::full({ m }, 1.0 / m, torch::kFloat64);
-        auto X_ = dataset.index({ torch::indexing::Slice(0, dataset.size(0) - 1), "..." });
-        auto y_ = dataset.index({ -1, "..." });
        bool exitCondition = false;
        unordered_set<int> featuresUsed;
+        // Variables to control the accuracy finish condition
+        double priorAccuracy = 0.0;
+        double delta = 1.0;
+        double threshold = 1e-4;
+        int tolerance = 5; // number of times the accuracy can be lower than the threshold
+        int count = 0; // number of times the accuracy is lower than the threshold
+        fitted = true; // to enable predict
        // Step 0: Set the finish condition
        // if not repeatSparent a finish condition is run out of features
        // n_models == maxModels
+        // epsiolon sub t > 0.5 => inverse the weights policy
+        // validation error is not decreasing
        while (!exitCondition) {
            // Step 1: Build ranking with mutual information
            auto featureSelection = metrics.SelectKBestWeighted(weights_, ascending, n); // Get all the features sorted
@@ -59,29 +102,44 @@ namespace bayesnet {
            }
            featuresUsed.insert(feature);
            model = std::make_unique<SPODE>(feature);
-            n_models++;
            model->fit(dataset, features, className, states, weights_);
-            auto ypred = model->predict(X_);
+            auto ypred = model->predict(X_train);
            // Step 3.1: Compute the classifier amout of say
-            auto mask_wrong = ypred != y_;
+            auto mask_wrong = ypred != y_train;
+            auto mask_right = ypred == y_train;
            auto masked_weights = weights_ * mask_wrong.to(weights_.dtype());
-            double wrongWeights = masked_weights.sum().item<double>();
-            double significance = wrongWeights == 0 ? 1 : 0.5 * log((1 - wrongWeights) / wrongWeights);
+            double epsilon_t = masked_weights.sum().item<double>();
+            double wt = (1 - epsilon_t) / epsilon_t;
+            double alpha_t = epsilon_t == 0 ? 1 : 0.5 * log(wt);
            // Step 3.2: Update weights for next classifier
            // Step 3.2.1: Update weights of wrong samples
-            weights_ += mask_wrong.to(weights_.dtype()) * exp(significance) * weights_;
+            weights_ += mask_wrong.to(weights_.dtype()) * exp(alpha_t) * weights_;
+            // Step 3.2.2: Update weights of right samples
+            weights_ += mask_right.to(weights_.dtype()) * exp(-alpha_t) * weights_;
            // Step 3.3: Normalise the weights
            double totalWeights = torch::sum(weights_).item<double>();
            weights_ = weights_ / totalWeights;
            // Step 3.4: Store classifier and its accuracy to weigh its future vote
            models.push_back(std::move(model));
-            significanceModels.push_back(significance);
-            exitCondition = n_models == maxModels && repeatSparent;
+            significanceModels.push_back(alpha_t);
+            n_models++;
+            if (convergence) {
+                auto y_val_predict = predict(X_test);
+                double accuracy = (y_val_predict == y_test).sum().item<double>() / (double)y_test.size(0);
+                if (priorAccuracy == 0) {
+                    priorAccuracy = accuracy;
+                } else {
+                    delta = accuracy - priorAccuracy;
+                }
+                if (delta < threshold) {
+                    count++;
+                }
+            }
+            exitCondition = n_models == maxModels && repeatSparent || epsilon_t > 0.5 || count > tolerance;
        }
        if (featuresUsed.size() != features.size()) {
-            cout << "Warning: BoostAODE did not use all the features" << endl;
+            status = WARNING;
        }
-        weights.copy_(weights_);
    }
    vector<string> BoostAODE::graph(const string& title) const
    {
--- a/src/BayesNet/BoostAODE.h
+++ b/src/BayesNet/BoostAODE.h
@@ -13,9 +13,13 @@ namespace bayesnet {
        void buildModel(const torch::Tensor& weights) override;
        void trainModel(const torch::Tensor& weights) override;
    private:
-        bool repeatSparent=false;
-        int maxModels=0;
-        bool ascending=false; //Process KBest features ascending or descending order
+        torch::Tensor dataset_;
+        torch::Tensor X_train, y_train, X_test, y_test;
+        void validationInit();
+        bool repeatSparent = false;
+        int maxModels = 0;
+        bool ascending = false; //Process KBest features ascending or descending order
+        bool convergence = false; //if true, stop when the model does not improve
    };
 }
 #endif
--- a/src/BayesNet/Classifier.cc
+++ b/src/BayesNet/Classifier.cc
@@ -75,7 +75,7 @@ namespace bayesnet {
            throw invalid_argument("dataset (X, y) must be of type Integer");
        }
        if (n != features.size()) {
-            throw invalid_argument("X " + to_string(n) + " and features " + to_string(features.size()) + " must have the same number of features");
+            throw invalid_argument("Classifier: X " + to_string(n) + " and features " + to_string(features.size()) + " must have the same number of features");
        }
        if (states.find(className) == states.end()) {
            throw invalid_argument("className not found in states");
--- a/src/BayesNet/Classifier.h
+++ b/src/BayesNet/Classifier.h
@@ -10,7 +10,6 @@ using namespace torch;
 namespace bayesnet {
    class Classifier : public BaseClassifier {
    private:
-        void buildDataset(torch::Tensor& y);
        Classifier& build(const vector<string>& features, const string& className, map<string, vector<int>>& states, const torch::Tensor& weights);
    protected:
        bool fitted;
@@ -21,10 +20,12 @@ namespace bayesnet {
        string className;
        map<string, vector<int>> states;
        Tensor dataset; // (n+1)xm tensor
+        status_t status = NORMAL;
        void checkFitParameters();
        virtual void buildModel(const torch::Tensor& weights) = 0;
        void trainModel(const torch::Tensor& weights) override;
        void checkHyperparameters(const vector<string>& validKeys, nlohmann::json& hyperparameters);
+        void buildDataset(torch::Tensor& y);
    public:
        Classifier(Network model);
        virtual ~Classifier() = default;
@@ -37,6 +38,7 @@ namespace bayesnet {
        int getNumberOfEdges() const override;
        int getNumberOfStates() const override;
        Tensor predict(Tensor& X) override;
+        status_t getStatus() const override { return status; }
        vector<int> predict(vector<vector<int>>& X) override;
        float score(Tensor& X, Tensor& y) override;
        float score(vector<vector<int>>& X, vector<int>& y) override;
--- a/src/BayesNet/Ensemble.cc
+++ b/src/BayesNet/Ensemble.cc
@@ -24,7 +24,7 @@ namespace bayesnet {
            // i.e. votes[0] contains how much value has the value 0 of class. That value is generated by the models predictions
            vector<double> votes(numClasses, 0.0);
            for (int j = 0; j < n_models; ++j) {
-                votes[y_pred_[i][j]] += significanceModels[j];
+                votes[y_pred_[i][j]] += significanceModels.at(j);
            }
            // argsort in descending order
            auto indices = argsort(votes);
--- a/src/BayesNet/Network.cc
+++ b/src/BayesNet/Network.cc
@@ -132,10 +132,10 @@ namespace bayesnet {
    void Network::setStates(const map<string, vector<int>>& states)
    {
        // Set states to every Node in the network
-        for (int i = 0; i < features.size(); ++i) {
-            nodes[features[i]]->setNumStates(states.at(features[i]).size());
-        }
-        classNumStates = nodes[className]->getNumStates();
+        for_each(features.begin(), features.end(), [this, &states](const string& feature) {
+            nodes.at(feature)->setNumStates(states.at(feature).size());
+            });
+        classNumStates = nodes.at(className)->getNumStates();
    }
    // X comes in nxm, where n is the number of features and m the number of samples
    void Network::fit(const torch::Tensor& X, const torch::Tensor& y, const torch::Tensor& weights, const vector<string>& featureNames, const string& className, const map<string, vector<int>>& states)
@@ -174,10 +174,16 @@ namespace bayesnet {
    {
        setStates(states);
        laplaceSmoothing = 1.0 / samples.size(1); // To use in CPT computation
+        vector<thread> threads;
        for (auto& node : nodes) {
-            node.second->computeCPT(samples, features, laplaceSmoothing, weights);
-            fitted = true;
+            threads.emplace_back([this, &node, &weights]() {
+                node.second->computeCPT(samples, features, laplaceSmoothing, weights);
+                });
        }
+        for (auto& thread : threads) {
+            thread.join();
+        }
+        fitted = true;
    }
    torch::Tensor Network::predict_tensor(const torch::Tensor& samples, const bool proba)
    {
--- a/src/Platform/CMakeLists.txt
+++ b/src/Platform/CMakeLists.txt
@@ -5,8 +5,12 @@ include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
 include_directories(${BayesNet_SOURCE_DIR}/lib/argparse/include)
 include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
 add_executable(main main.cc Folding.cc platformUtils.cc Experiment.cc Datasets.cc Models.cc ReportConsole.cc ReportBase.cc)
-add_executable(manage manage.cc Results.cc ReportConsole.cc ReportExcel.cc ReportBase.cc)
+add_executable(manage manage.cc Results.cc ReportConsole.cc ReportExcel.cc ReportBase.cc Datasets.cc platformUtils.cc)
 add_executable(list list.cc platformUtils Datasets.cc)
 target_link_libraries(main BayesNet ArffFiles mdlp "${TORCH_LIBRARIES}")
-target_link_libraries(manage "${TORCH_LIBRARIES}" OpenXLSX::OpenXLSX)
+if (${CMAKE_HOST_SYSTEM_NAME} MATCHES "Linux")
+    target_link_libraries(manage "${TORCH_LIBRARIES}" libxlsxwriter.so ArffFiles mdlp stdc++fs)
+else()
+    target_link_libraries(manage "${TORCH_LIBRARIES}" libxlsxwriter.so ArffFiles mdlp)
+endif()
 target_link_libraries(list ArffFiles mdlp "${TORCH_LIBRARIES}")
--- a/src/Platform/Experiment.cc
+++ b/src/Platform/Experiment.cc
@@ -111,6 +111,26 @@ namespace platform {
        }
    }

+    string getColor(bayesnet::status_t status)
+    {
+        switch (status) {
+            case bayesnet::NORMAL:
+                return Colors::GREEN();
+            case bayesnet::WARNING:
+                return Colors::YELLOW();
+            case bayesnet::ERROR:
+                return Colors::RED();
+            default:
+                return Colors::RESET();
+        }
+    }
+
+    void showProgress(int fold, const string& color, const string& phase)
+    {
+        string prefix = phase == "a" ? "" : "\b\b\b\b";
+        cout << prefix << color << fold << Colors::RESET() << "(" << color << phase << Colors::RESET() << ")" << flush;
+
+    }
    void Experiment::cross_validation(const string& path, const string& fileName)
    {
        auto datasets = platform::Datasets(path, discretized, platform::ARFF);
@@ -159,20 +179,24 @@ namespace platform {
                auto y_train = y.index({ train_t });
                auto X_test = X.index({ "...", test_t });
                auto y_test = y.index({ test_t });
-                cout << nfold + 1 << ", " << flush;
+                showProgress(nfold + 1, getColor(clf->getStatus()), "a");
                // Train model
                clf->fit(X_train, y_train, features, className, states);
+                showProgress(nfold + 1, getColor(clf->getStatus()), "b");
                nodes[item] = clf->getNumberOfNodes();
                edges[item] = clf->getNumberOfEdges();
                num_states[item] = clf->getNumberOfStates();
                train_time[item] = train_timer.getDuration();
+                // Score train
                auto accuracy_train_value = clf->score(X_train, y_train);
                // Test model
+                showProgress(nfold + 1, getColor(clf->getStatus()), "c");
                test_timer.start();
                auto accuracy_test_value = clf->score(X_test, y_test);
                test_time[item] = test_timer.getDuration();
                accuracy_train[item] = accuracy_train_value;
                accuracy_test[item] = accuracy_test_value;
+                cout << "\b\b\b, " << flush;
                // Store results and times in vector
                result.addScoreTrain(accuracy_train_value);
                result.addScoreTest(accuracy_test_value);
--- a/src/Platform/ReportBase.cc
+++ b/src/Platform/ReportBase.cc
@@ -1,10 +1,22 @@
 #include <sstream>
 #include <locale>
+#include "Datasets.h"
 #include "ReportBase.h"
 #include "BestResult.h"


 namespace platform {
+    ReportBase::ReportBase(json data_, bool compare) : data(data_), compare(compare), margin(0.1)
+    {
+        stringstream oss;
+        oss << "Better than ZeroR + " << setprecision(1) << fixed << margin * 100 << "%";
+        meaning = {
+            {Symbols::equal_best, "Equal to best"},
+            {Symbols::better_best, "Better than best"},
+            {Symbols::cross, "Less than or equal to ZeroR"},
+            {Symbols::upward_arrow, oss.str()}
+        };
+    }
    string ReportBase::fromVector(const string& key)
    {
        stringstream oss;
@@ -34,4 +46,62 @@ namespace platform {
        header();
        body();
    }
+    string ReportBase::compareResult(const string& dataset, double result)
+    {
+        string status = " ";
+        if (compare) {
+            double best = bestResult(dataset, data["model"].get<string>());
+            if (result == best) {
+                status = Symbols::equal_best;
+            } else if (result > best) {
+                status = Symbols::better_best;
+            }
+        } else {
+            if (data["score_name"].get<string>() == "accuracy") {
+                auto dt = Datasets(Paths::datasets(), false);
+                dt.loadDataset(dataset);
+                auto numClasses = dt.getNClasses(dataset);
+                if (numClasses == 2) {
+                    vector<int> distribution = dt.getClassesCounts(dataset);
+                    double nSamples = dt.getNSamples(dataset);
+                    vector<int>::iterator maxValue = max_element(distribution.begin(), distribution.end());
+                    double mark = *maxValue / nSamples * (1 + margin);
+                    if (mark > 1) {
+                        mark = 0.9995;
+                    }
+                    status = result < mark ? Symbols::cross : result > mark ? Symbols::upward_arrow : "=";
+                }
+            }
+        }
+        if (status != " ") {
+            auto item = summary.find(status);
+            if (item != summary.end()) {
+                summary[status]++;
+            } else {
+                summary[status] = 1;
+            }
+        }
+        return status;
+    }
+    double ReportBase::bestResult(const string& dataset, const string& model)
+    {
+        double value = 0.0;
+        if (bestResults.size() == 0) {
+            // try to load the best results
+            string score = data["score_name"];
+            replace(score.begin(), score.end(), '_', '-');
+            string fileName = "best_results_" + score + "_" + model + ".json";
+            ifstream resultData(Paths::results() + "/" + fileName);
+            if (resultData.is_open()) {
+                bestResults = json::parse(resultData);
+            }
+        }
+        try {
+            value = bestResults.at(dataset).at(0);
+        }
+        catch (exception) {
+            value = 1.0;
+        }
+        return value;
+    }
 }
--- a/src/Platform/ReportBase.h
+++ b/src/Platform/ReportBase.h
@@ -2,14 +2,26 @@
 #define REPORTBASE_H
 #include <string>
 #include <iostream>
+#include "Paths.h"
 #include <nlohmann/json.hpp>

 using json = nlohmann::json;
 namespace platform {
    using namespace std;
+    class Symbols {
+    public:
+        inline static const string check_mark{ "\u2714" };
+        inline static const string exclamation{ "\u2757" };
+        inline static const string black_star{ "\u2605" };
+        inline static const string cross{ "\u2717" };
+        inline static const string upward_arrow{ "\u27B6" };
+        inline static const string down_arrow{ "\u27B4" };
+        inline static const string equal_best{ check_mark };
+        inline static const string better_best{ black_star };
+    };
    class ReportBase {
    public:
-        explicit ReportBase(json data_) { data = data_; };
+        explicit ReportBase(json data_, bool compare);
        virtual ~ReportBase() = default;
        void show();
    protected:
@@ -18,6 +30,15 @@ namespace platform {
        string fVector(const string& title, const json& data, const int width, const int precision);
        virtual void header() = 0;
        virtual void body() = 0;
+        virtual void showSummary() = 0;
+        string compareResult(const string& dataset, double result);
+        map<string, int> summary;
+        double margin;
+        map<string, string> meaning;
+    private:
+        double bestResult(const string& dataset, const string& model);
+        bool compare;
+        json bestResults;
    };
 };
 #endif
--- a/src/Platform/ReportConsole.cc
+++ b/src/Platform/ReportConsole.cc
@@ -11,11 +11,11 @@ namespace platform {
        string do_grouping() const { return "\03"; }
    };

-    string ReportConsole::headerLine(const string& text)
+    string ReportConsole::headerLine(const string& text, int utf = 0)
    {
        int n = MAXL - text.length() - 3;
        n = n < 0 ? 0 : n;
-        return "* " + text + string(n, ' ') + "*\n";
+        return "* " + text + string(n + utf, ' ') + "*\n";
    }

    void ReportConsole::header()
@@ -36,22 +36,31 @@ namespace platform {
    }
    void ReportConsole::body()
    {
-        cout << Colors::GREEN() << "Dataset                        Sampl. Feat. Cls Nodes     Edges     States    Score           Time               Hyperparameters" << endl;
-        cout << "============================== ====== ===== === ========= ========= ========= =============== ================== ===============" << endl;
+        cout << Colors::GREEN() << " #  Dataset                   Sampl. Feat. Cls Nodes     Edges     States    Score           Time                Hyperparameters" << endl;
+        cout << "=== ========================= ====== ===== === ========= ========= ========= =============== =================== ====================" << endl;
        json lastResult;
        double totalScore = 0.0;
        bool odd = true;
+        int index = 0;
        for (const auto& r : data["results"]) {
+            if (selectedIndex != -1 && index != selectedIndex) {
+                index++;
+                continue;
+            }
            auto color = odd ? Colors::CYAN() : Colors::BLUE();
-            cout << color << setw(30) << left << r["dataset"].get<string>() << " ";
+            cout << color;
+            cout << setw(3) << index++ << " ";
+            cout << setw(25) << left << r["dataset"].get<string>() << " ";
            cout << setw(6) << right << r["samples"].get<int>() << " ";
            cout << setw(5) << right << r["features"].get<int>() << " ";
            cout << setw(3) << right << r["classes"].get<int>() << " ";
            cout << setw(9) << setprecision(2) << fixed << r["nodes"].get<float>() << " ";
            cout << setw(9) << setprecision(2) << fixed << r["leaves"].get<float>() << " ";
            cout << setw(9) << setprecision(2) << fixed << r["depth"].get<float>() << " ";
-            cout << setw(8) << right << setprecision(6) << fixed << r["score"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["score_std"].get<double>() << " ";
-            cout << setw(11) << right << setprecision(6) << fixed << r["time"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["time_std"].get<double>() << " ";
+            cout << setw(8) << right << setprecision(6) << fixed << r["score"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["score_std"].get<double>();
+            const string status = compareResult(r["dataset"].get<string>(), r["score"].get<double>());
+            cout << status;
+            cout << setw(12) << right << setprecision(6) << fixed << r["time"].get<double>() << "±" << setw(6) << setprecision(4) << fixed << r["time_std"].get<double>() << " ";
            try {
                cout << r["hyperparameters"].get<string>();
            }
@@ -63,7 +72,7 @@ namespace platform {
            totalScore += r["score"].get<double>();
            odd = !odd;
        }
-        if (data["results"].size() == 1) {
+        if (data["results"].size() == 1 || selectedIndex != -1) {
            cout << string(MAXL, '*') << endl;
            cout << headerLine(fVector("Train scores: ", lastResult["scores_train"], 14, 12));
            cout << headerLine(fVector("Test  scores: ", lastResult["scores_test"], 14, 12));
@@ -74,9 +83,21 @@ namespace platform {
            footer(totalScore);
        }
    }
+    void ReportConsole::showSummary()
+    {
+        for (const auto& item : summary) {
+            stringstream oss;
+            oss << setw(3) << left << item.first;
+            oss << setw(3) << right << item.second << " ";
+            oss << left << meaning.at(item.first);
+            cout << headerLine(oss.str(), 2);
+        }
+    }
+
    void ReportConsole::footer(double totalScore)
    {
        cout << Colors::MAGENTA() << string(MAXL, '*') << endl;
+        showSummary();
        auto score = data["score_name"].get<string>();
        if (score == BestResult::scoreName()) {
            stringstream oss;
--- a/src/Platform/ReportConsole.h
+++ b/src/Platform/ReportConsole.h
@@ -7,16 +7,18 @@

 namespace platform {
    using namespace std;
-    const int MAXL = 128;
-    class ReportConsole : public ReportBase{
+    const int MAXL = 133;
+    class ReportConsole : public ReportBase {
    public:
-        explicit ReportConsole(json data_) : ReportBase(data_) {};
+        explicit ReportConsole(json data_, bool compare = false, int index = -1) : ReportBase(data_, compare), selectedIndex(index) {};
        virtual ~ReportConsole() = default;
    private:
-        string headerLine(const string& text);
+        int selectedIndex;
+        string headerLine(const string& text, int utf);
        void header() override;
        void body() override;
        void footer(double totalScore);
+        void showSummary();
    };
 };
 #endif
--- a/src/Platform/ReportExcel.cc
+++ b/src/Platform/ReportExcel.cc
@@ -13,17 +13,195 @@ namespace platform {
        string do_grouping() const { return "\03"; }
    };

+    ReportExcel::ReportExcel(json data_, bool compare, lxw_workbook* workbook) : ReportBase(data_, compare), row(0), workbook(workbook)
+    {
+        normalSize = 14; //font size for report body
+        colorTitle = 0xB1A0C7;
+        colorOdd = 0xDCE6F1;
+        colorEven = 0xFDE9D9;
+        createFile();
+    }
+
+    lxw_workbook* ReportExcel::getWorkbook()
+    {
+        return workbook;
+    }
+
+    lxw_format* ReportExcel::efectiveStyle(const string& style)
+    {
+        lxw_format* efectiveStyle;
+        if (style == "") {
+            efectiveStyle = NULL;
+        } else {
+            string suffix = row % 2 ? "_odd" : "_even";
+            efectiveStyle = styles.at(style + suffix);
+        }
+        return efectiveStyle;
+    }
+
+    void ReportExcel::writeString(int row, int col, const string& text, const string& style)
+    {
+        worksheet_write_string(worksheet, row, col, text.c_str(), efectiveStyle(style));
+    }
+    void ReportExcel::writeInt(int row, int col, const int number, const string& style)
+    {
+        worksheet_write_number(worksheet, row, col, number, efectiveStyle(style));
+    }
+    void ReportExcel::writeDouble(int row, int col, const double number, const string& style)
+    {
+        worksheet_write_number(worksheet, row, col, number, efectiveStyle(style));
+    }
+
+    void ReportExcel::formatColumns()
+    {
+        worksheet_freeze_panes(worksheet, 6, 1);
+        vector<int> columns_sizes = { 22, 10, 9, 7, 12, 12, 12, 12, 12, 3, 15, 12, 23 };
+        for (int i = 0; i < columns_sizes.size(); ++i) {
+            worksheet_set_column(worksheet, i, i, columns_sizes.at(i), NULL);
+        }
+    }
+
+    void ReportExcel::addColor(lxw_format* style, bool odd)
+    {
+        uint32_t efectiveColor = odd ? colorEven : colorOdd;
+        format_set_bg_color(style, lxw_color_t(efectiveColor));
+    }
+    void ReportExcel::createStyle(const string& name, lxw_format* style, bool odd)
+    {
+        addColor(style, odd);
+        if (name == "textCentered") {
+            format_set_align(style, LXW_ALIGN_CENTER);
+            format_set_font_size(style, normalSize);
+            format_set_border(style, LXW_BORDER_THIN);
+        } else if (name == "text") {
+            format_set_font_size(style, normalSize);
+            format_set_border(style, LXW_BORDER_THIN);
+        } else if (name == "bodyHeader") {
+            format_set_bold(style);
+            format_set_font_size(style, normalSize);
+            format_set_align(style, LXW_ALIGN_CENTER);
+            format_set_align(style, LXW_ALIGN_VERTICAL_CENTER);
+            format_set_border(style, LXW_BORDER_THIN);
+            format_set_bg_color(style, lxw_color_t(colorTitle));
+        } else if (name == "result") {
+            format_set_font_size(style, normalSize);
+            format_set_border(style, LXW_BORDER_THIN);
+            format_set_num_format(style, "0.0000000");
+        } else if (name == "time") {
+            format_set_font_size(style, normalSize);
+            format_set_border(style, LXW_BORDER_THIN);
+            format_set_num_format(style, "#,##0.000000");
+        } else if (name == "ints") {
+            format_set_font_size(style, normalSize);
+            format_set_num_format(style, "###,##0");
+            format_set_border(style, LXW_BORDER_THIN);
+        } else if (name == "floats") {
+            format_set_border(style, LXW_BORDER_THIN);
+            format_set_font_size(style, normalSize);
+            format_set_num_format(style, "#,##0.00");
+        }
+    }
+
+    void ReportExcel::createFormats()
+    {
+        auto styleNames = { "text", "textCentered", "bodyHeader", "result", "time", "ints", "floats" };
+        lxw_format* style;
+        for (string name : styleNames) {
+            lxw_format* style = workbook_add_format(workbook);
+            style = workbook_add_format(workbook);
+            createStyle(name, style, true);
+            styles[name + "_odd"] = style;
+            style = workbook_add_format(workbook);
+            createStyle(name, style, false);
+            styles[name + "_even"] = style;
+        }
+
+        // Header 1st line
+        lxw_format* headerFirst = workbook_add_format(workbook);
+        format_set_bold(headerFirst);
+        format_set_font_size(headerFirst, 18);
+        format_set_align(headerFirst, LXW_ALIGN_CENTER);
+        format_set_align(headerFirst, LXW_ALIGN_VERTICAL_CENTER);
+        format_set_border(headerFirst, LXW_BORDER_THIN);
+        format_set_bg_color(headerFirst, lxw_color_t(colorTitle));
+
+        // Header rest
+        lxw_format* headerRest = workbook_add_format(workbook);
+        format_set_bold(headerRest);
+        format_set_align(headerRest, LXW_ALIGN_CENTER);
+        format_set_font_size(headerRest, 16);
+        format_set_align(headerRest, LXW_ALIGN_VERTICAL_CENTER);
+        format_set_border(headerRest, LXW_BORDER_THIN);
+        format_set_bg_color(headerRest, lxw_color_t(colorOdd));
+
+        // Header small
+        lxw_format* headerSmall = workbook_add_format(workbook);
+        format_set_bold(headerSmall);
+        format_set_align(headerSmall, LXW_ALIGN_LEFT);
+        format_set_font_size(headerSmall, 12);
+        format_set_border(headerSmall, LXW_BORDER_THIN);
+        format_set_align(headerSmall, LXW_ALIGN_VERTICAL_CENTER);
+        format_set_bg_color(headerSmall, lxw_color_t(colorOdd));
+
+        // Summary style
+        lxw_format* summaryStyle = workbook_add_format(workbook);
+        format_set_bold(summaryStyle);
+        format_set_font_size(summaryStyle, 16);
+        format_set_border(summaryStyle, LXW_BORDER_THIN);
+        format_set_align(summaryStyle, LXW_ALIGN_VERTICAL_CENTER);
+
+        styles["headerFirst"] = headerFirst;
+        styles["headerRest"] = headerRest;
+        styles["headerSmall"] = headerSmall;
+        styles["summaryStyle"] = summaryStyle;
+    }
+
+    void ReportExcel::setProperties()
+    {
+        char line[data["title"].get<string>().size() + 1];
+        strcpy(line, data["title"].get<string>().c_str());
+        lxw_doc_properties properties = {
+            .title = line,
+            .subject = "Machine learning results",
+            .author = "Ricardo Montañana Gómez",
+            .manager = "Dr. J. A. Gámez, Dr. J. M. Puerta",
+            .company = "UCLM",
+            .comments = "Created with libxlsxwriter and c++",
+        };
+        workbook_set_properties(workbook, &properties);
+    }
+
    void ReportExcel::createFile()
    {
-        doc.create(Paths::excel() + "some_results.xlsx");
-        wks = doc.workbook().worksheet("Sheet1");
-        wks.setName(data["model"].get<string>());
+        if (workbook == NULL) {
+            workbook = workbook_new((Paths::excel() + fileName).c_str());
+        }
+        const string name = data["model"].get<string>();
+        string suffix = "";
+        string efectiveName;
+        int num = 1;
+        // Create a sheet with the name of the model
+        while (true) {
+            efectiveName = name + suffix;
+            if (workbook_get_worksheet_by_name(workbook, efectiveName.c_str())) {
+                suffix = to_string(++num);
+            } else {
+                worksheet = workbook_add_worksheet(workbook, efectiveName.c_str());
+                break;
+            }
+            if (num > 100) {
+                throw invalid_argument("Couldn't create sheet " + efectiveName);
+            }
+        }
+        cout << "Adding sheet " << efectiveName << " to " << Paths::excel() + fileName << endl;
+        setProperties();
+        createFormats();
+        formatColumns();
    }

    void ReportExcel::closeFile()
    {
-        doc.save();
-        doc.close();
+        workbook_close(workbook);
    }

    void ReportExcel::header()
@@ -32,45 +210,62 @@ namespace platform {
        locale::global(mylocale);
        cout.imbue(mylocale);
        stringstream oss;
-        wks.cell("A1").value().set(
-            "Report " + data["model"].get<string>() + " ver. " + data["version"].get<string>() + " with " +
-            to_string(data["folds"].get<int>()) + " Folds cross validation and " + to_string(data["seeds"].size()) +
-            " random seeds. " + data["date"].get<string>() + " " + data["time"].get<string>());
-        wks.cell("A2").value() = data["title"].get<string>();
-        wks.cell("A3").value() = "Random seeds: " + fromVector("seeds") + " Stratified: " +
-            (data["stratified"].get<bool>() ? "True" : "False");
-        oss << "Execution took  " << setprecision(2) << fixed << data["duration"].get<float>() << " seconds,   "
-            << data["duration"].get<float>() / 3600 << " hours, on " << data["platform"].get<string>();
-        wks.cell("A4").value() = oss.str();
-        wks.cell("A5").value() = "Score is " + data["score_name"].get<string>();
+        string message = data["model"].get<string>() + " ver. " + data["version"].get<string>() + " " +
+            data["language"].get<string>() + " ver. " + data["language_version"].get<string>() +
+            " with " + to_string(data["folds"].get<int>()) + " Folds cross validation and " + to_string(data["seeds"].size()) +
+            " random seeds. " + data["date"].get<string>() + " " + data["time"].get<string>();
+        worksheet_merge_range(worksheet, 0, 0, 0, 12, message.c_str(), styles["headerFirst"]);
+        worksheet_merge_range(worksheet, 1, 0, 1, 12, data["title"].get<string>().c_str(), styles["headerRest"]);
+        worksheet_merge_range(worksheet, 2, 0, 3, 0, ("Score is " + data["score_name"].get<string>()).c_str(), styles["headerRest"]);
+        worksheet_merge_range(worksheet, 2, 1, 3, 3, "Execution time", styles["headerRest"]);
+        oss << setprecision(2) << fixed << data["duration"].get<float>() << " s";
+        worksheet_merge_range(worksheet, 2, 4, 2, 5, oss.str().c_str(), styles["headerRest"]);
+        oss.str("");
+        oss.clear();
+        oss << setprecision(2) << fixed << data["duration"].get<float>() / 3600 << " h";
+        worksheet_merge_range(worksheet, 3, 4, 3, 5, oss.str().c_str(), styles["headerRest"]);
+        worksheet_merge_range(worksheet, 2, 6, 3, 7, "Platform", styles["headerRest"]);
+        worksheet_merge_range(worksheet, 2, 8, 3, 9, data["platform"].get<string>().c_str(), styles["headerRest"]);
+        worksheet_merge_range(worksheet, 2, 10, 2, 12, ("Random seeds: " + fromVector("seeds")).c_str(), styles["headerSmall"]);
+        oss.str("");
+        oss.clear();
+        oss << "Stratified: " << (data["stratified"].get<bool>() ? "True" : "False");
+        worksheet_merge_range(worksheet, 3, 10, 3, 11, oss.str().c_str(), styles["headerSmall"]);
+        oss.str("");
+        oss.clear();
+        oss << "Discretized: " << (data["discretized"].get<bool>() ? "True" : "False");
+        worksheet_write_string(worksheet, 3, 12, oss.str().c_str(), styles["headerSmall"]);
    }

    void ReportExcel::body()
    {
        auto head = vector<string>(
-            { "Dataset", "Samples", "Features", "Classes", "Nodes", "Edges", "States", "Score", "Score Std.", "Time",
+            { "Dataset", "Samples", "Features", "Classes", "Nodes", "Edges", "States", "Score", "Score Std.", "St.", "Time",
             "Time Std.", "Hyperparameters" });
-        int col = 1;
+        int col = 0;
        for (const auto& item : head) {
-            wks.cell(8, col++).value() = item;
+            writeString(5, col++, item, "bodyHeader");
        }
-        int row = 9;
-        col = 1;
+        row = 6;
+        col = 0;
+        int hypSize = 22;
        json lastResult;
        double totalScore = 0.0;
        string hyperparameters;
        for (const auto& r : data["results"]) {
-            wks.cell(row, col).value() = r["dataset"].get<string>();
-            wks.cell(row, col + 1).value() = r["samples"].get<int>();
-            wks.cell(row, col + 2).value() = r["features"].get<int>();
-            wks.cell(row, col + 3).value() = r["classes"].get<int>();
-            wks.cell(row, col + 4).value() = r["nodes"].get<float>();
-            wks.cell(row, col + 5).value() = r["leaves"].get<float>();
-            wks.cell(row, col + 6).value() = r["depth"].get<float>();
-            wks.cell(row, col + 7).value() = r["score"].get<double>();
-            wks.cell(row, col + 8).value() = r["score_std"].get<double>();
-            wks.cell(row, col + 9).value() = r["time"].get<double>();
-            wks.cell(row, col + 10).value() = r["time_std"].get<double>();
+            writeString(row, col, r["dataset"].get<string>(), "text");
+            writeInt(row, col + 1, r["samples"].get<int>(), "ints");
+            writeInt(row, col + 2, r["features"].get<int>(), "ints");
+            writeInt(row, col + 3, r["classes"].get<int>(), "ints");
+            writeDouble(row, col + 4, r["nodes"].get<float>(), "floats");
+            writeDouble(row, col + 5, r["leaves"].get<float>(), "floats");
+            writeDouble(row, col + 6, r["depth"].get<double>(), "floats");
+            writeDouble(row, col + 7, r["score"].get<double>(), "result");
+            writeDouble(row, col + 8, r["score_std"].get<double>(), "result");
+            const string status = compareResult(r["dataset"].get<string>(), r["score"].get<double>());
+            writeString(row, col + 9, status, "textCentered");
+            writeDouble(row, col + 10, r["time"].get<double>(), "time");
+            writeDouble(row, col + 11, r["time_std"].get<double>(), "time");
            try {
                hyperparameters = r["hyperparameters"].get<string>();
            }
@@ -79,31 +274,57 @@ namespace platform {
                oss << r["hyperparameters"];
                hyperparameters = oss.str();
            }
-            wks.cell(row, col + 11).value() = hyperparameters;
+            if (hyperparameters.size() > hypSize) {
+                hypSize = hyperparameters.size();
+            }
+            writeString(row, col + 12, hyperparameters, "text");
            lastResult = r;
            totalScore += r["score"].get<double>();
            row++;
+
        }
+        // Set the right column width of hyperparameters with the maximum length
+        worksheet_set_column(worksheet, 12, 12, hypSize + 5, NULL);
+        // Show totals if only one dataset is present in the result
        if (data["results"].size() == 1) {
            for (const string& group : { "scores_train", "scores_test", "times_train", "times_test" }) {
                row++;
                col = 1;
-                wks.cell(row, col).value() = group;
+                writeString(row, col, group, "text");
                for (double item : lastResult[group]) {
-                    wks.cell(row, ++col).value() = item;
+                    string style = group.find("scores") != string::npos ? "result" : "time";
+                    writeDouble(row, ++col, item, style);
                }
            }
+            // Set with of columns to show those totals completely
+            worksheet_set_column(worksheet, 1, 1, 12, NULL);
+            for (int i = 2; i < 7; ++i) {
+                // doesn't work with from col to col, so...
+                worksheet_set_column(worksheet, i, i, 15, NULL);
+            }
        } else {
            footer(totalScore, row);
        }
    }

+    void ReportExcel::showSummary()
+    {
+        for (const auto& item : summary) {
+            worksheet_write_string(worksheet, row + 2, 1, item.first.c_str(), styles["summaryStyle"]);
+            worksheet_write_number(worksheet, row + 2, 2, item.second, styles["summaryStyle"]);
+            worksheet_merge_range(worksheet, row + 2, 3, row + 2, 5, meaning.at(item.first).c_str(), styles["summaryStyle"]);
+            row += 1;
+        }
+    }
+
    void ReportExcel::footer(double totalScore, int row)
    {
+        showSummary();
+        row += 4 + summary.size();
        auto score = data["score_name"].get<string>();
        if (score == BestResult::scoreName()) {
-            wks.cell(row + 2, 1).value() = score + " compared to " + BestResult::title() + " .:  ";
-            wks.cell(row + 2, 5).value() = totalScore / BestResult::score();
+            worksheet_merge_range(worksheet, row, 1, row, 5, (score + " compared to " + BestResult::title() + " .:").c_str(), efectiveStyle("text"));
+            writeDouble(row, 6, totalScore / BestResult::score(), "result");
        }
    }
 }
--- a/src/Platform/ReportExcel.h
+++ b/src/Platform/ReportExcel.h
@@ -1,25 +1,42 @@
 #ifndef REPORTEXCEL_H
 #define REPORTEXCEL_H
-#include <OpenXLSX.hpp>
+#include<map>
+#include "xlsxwriter.h"
 #include "ReportBase.h"
-#include "Paths.h"
 #include "Colors.h"
 namespace platform {
    using namespace std;
-    using namespace OpenXLSX;
    const int MAXLL = 128;
-    class ReportExcel : public ReportBase{
+
+    class ReportExcel : public ReportBase {
    public:
-        explicit ReportExcel(json data_) : ReportBase(data_) {createFile();};
-        virtual ~ReportExcel() {closeFile();};
+        explicit ReportExcel(json data_, bool compare, lxw_workbook* workbook);
+        lxw_workbook* getWorkbook();
    private:
+        void writeString(int row, int col, const string& text, const string& style = "");
+        void writeInt(int row, int col, const int number, const string& style = "");
+        void writeDouble(int row, int col, const double number, const string& style = "");
+        void formatColumns();
+        void createFormats();
+        void setProperties();
        void createFile();
        void closeFile();
-        XLDocument doc;
-        XLWorksheet wks;
+        void showSummary();
+        lxw_workbook* workbook;
+        lxw_worksheet* worksheet;
+        map<string, lxw_format*> styles;
+        int row;
+        int normalSize; //font size for report body
+        uint32_t colorTitle;
+        uint32_t colorOdd;
+        uint32_t colorEven;
+        const string fileName = "some_results.xlsx";
        void header() override;
        void body() override;
        void footer(double totalScore, int row);
+        void createStyle(const string& name, lxw_format* style, bool odd);
+        void addColor(lxw_format* style, bool odd);
+        lxw_format* efectiveStyle(const string& name);
    };
 };
 #endif // !REPORTEXCEL_H
--- a/src/Platform/Results.cc
+++ b/src/Platform/Results.cc
@@ -23,6 +23,7 @@ namespace platform {
        title = data["title"];
        duration = data["duration"];
        model = data["model"];
+        complete = data["results"].size() > 1;
    }
    json Result::load() const
    {
@@ -41,7 +42,7 @@ namespace platform {
            if (filename.find(".json") != string::npos && filename.find("results_") == 0) {
                auto result = Result(path, filename);
                bool addResult = true;
-                if (model != "any" && result.getModel() != model || scoreName != "any" && scoreName != result.getScoreName())
+                if (model != "any" && result.getModel() != model || scoreName != "any" && scoreName != result.getScoreName() || complete && !result.isComplete() || partial && result.isComplete())
                    addResult = false;
                if (addResult)
                    files.push_back(result);
@@ -55,6 +56,8 @@ namespace platform {
        oss << setw(12) << left << model << " ";
        oss << setw(11) << left << scoreName << " ";
        oss << right << setw(11) << setprecision(7) << fixed << score << " ";
+        auto completeString = isComplete() ? "C" : "P";
+        oss << setw(1) << " " << completeString << "  ";
        oss << setw(9) << setprecision(3) << fixed << duration << " ";
        oss << setw(50) << left << title << " ";
        return  oss.str();
@@ -63,9 +66,15 @@ namespace platform {
    {
        cout << Colors::GREEN() << "Results found: " << files.size() << endl;
        cout << "-------------------" << endl;
+        if (complete) {
+            cout << Colors::MAGENTA() << "Only listing complete results" << endl;
+        }
+        if (partial) {
+            cout << Colors::MAGENTA() << "Only listing partial results" << endl;
+        }
        auto i = 0;
-        cout << " #  Date       Model        Score Name  Score       Duration  Title" << endl;
-        cout << "=== ========== ============ =========== =========== ========= =============================================================" << endl;
+        cout << Colors::GREEN() << " #  Date       Model        Score Name  Score       C/P Duration  Title" << endl;
+        cout << "=== ========== ============ =========== =========== === ========= =============================================================" << endl;
        bool odd = true;
        for (const auto& result : files) {
            auto color = odd ? Colors::BLUE() : Colors::CYAN();
@@ -95,26 +104,51 @@ namespace platform {
        cout << "Invalid index" << endl;
        return -1;
    }
-    void Results::report(const int index, const bool excelReport) const
+    void Results::report(const int index, const bool excelReport)
    {
        cout << Colors::YELLOW() << "Reporting " << files.at(index).getFilename() << endl;
        auto data = files.at(index).load();
        if (excelReport) {
-            ReportExcel reporter(data);
+            ReportExcel reporter(data, compare, workbook);
            reporter.show();
+            openExcel = true;
+            workbook = reporter.getWorkbook();
        } else {
-            ReportConsole reporter(data);
+            ReportConsole reporter(data, compare);
            reporter.show();
        }
    }
+    void Results::showIndex(const int index, const int idx) const
+    {
+        auto data = files.at(index).load();
+        if (idx < 0 or idx >= static_cast<int>(data["results"].size())) {
+            cout << "Invalid index" << endl;
+            return;
+        }
+        cout << Colors::YELLOW() << "Showing " << files.at(index).getFilename() << endl;
+        ReportConsole reporter(data, compare, idx);
+        reporter.show();
+    }
    void Results::menu()
    {
        char option;
        int index;
        bool finished = false;
+        string color, context;
        string filename, line, options = "qldhsre";
        while (!finished) {
-            cout << Colors::RESET() << "Choose option (quit='q', list='l', delete='d', hide='h', sort='s', report='r', excel='e'): ";
+            if (indexList) {
+                color = Colors::GREEN();
+                context = " (quit='q', list='l', delete='d', hide='h', sort='s', report='r', excel='e'): ";
+                options = "qldhsre";
+            } else {
+                color = Colors::MAGENTA();
+                context = " (quit='q', list='l'): ";
+                options = "ql";
+            }
+            cout << Colors::RESET() << color;
+
+            cout << "Choose option " << context;
            getline(cin, line);
            if (line.size() == 0)
                continue;
@@ -126,9 +160,18 @@ namespace platform {
                option = line[0];
            } else {
                if (all_of(line.begin(), line.end(), ::isdigit)) {
-                    index = stoi(line);
-                    if (index >= 0 && index < files.size()) {
-                        report(index, false);
+                    int idx = stoi(line);
+                    if (indexList) {
+                        // The value is about the files list
+                        index = idx;
+                        if (index >= 0 && index < files.size()) {
+                            report(index, false);
+                            indexList = false;
+                            continue;
+                        }
+                    } else {
+                        // The value is about the result showed on screen
+                        showIndex(index, idx);
                        continue;
                    }
                }
@@ -141,6 +184,7 @@ namespace platform {
                    break;
                case 'l':
                    show();
+                    indexList = true;
                    break;
                case 'd':
                    index = getIndex("delete");
@@ -152,6 +196,7 @@ namespace platform {
                    files.erase(files.begin() + index);
                    cout << "File: " + filename + " deleted!" << endl;
                    show();
+                    indexList = true;
                    break;
                case 'h':
                    index = getIndex("hide");
@@ -163,21 +208,25 @@ namespace platform {
                    files.erase(files.begin() + index);
                    show();
                    menu();
+                    indexList = true;
                    break;
                case 's':
                    sortList();
+                    indexList = true;
                    show();
                    break;
                case 'r':
                    index = getIndex("report");
                    if (index == -1)
                        break;
+                    indexList = false;
                    report(index, false);
                    break;
                case 'e':
                    index = getIndex("excel");
                    if (index == -1)
                        break;
+                    indexList = true;
                    report(index, true);
                    break;
                default:
@@ -248,6 +297,9 @@ namespace platform {
        sortDate();
        show();
        menu();
+        if (openExcel) {
+            workbook_close(workbook);
+        }
        cout << "Done!" << endl;
    }

--- a/src/Platform/Results.h
+++ b/src/Platform/Results.h
@@ -1,5 +1,6 @@
 #ifndef RESULTS_H
 #define RESULTS_H
+#include "xlsxwriter.h"
 #include <map>
 #include <vector>
 #include <string>
@@ -20,6 +21,7 @@ namespace platform {
        double getDuration() const { return duration; };
        string getModel() const { return model; };
        string getScoreName() const { return scoreName; };
+        bool isComplete() const { return complete; };
    private:
        string path;
        string filename;
@@ -29,20 +31,32 @@ namespace platform {
        double duration;
        string model;
        string scoreName;
+        bool complete;
    };
    class Results {
    public:
-        Results(const string& path, const int max, const string& model, const string& score) : path(path), max(max), model(model), scoreName(score) { load(); };
+        Results(const string& path, const int max, const string& model, const string& score, bool complete, bool partial, bool compare) :
+            path(path), max(max), model(model), scoreName(score), complete(complete), partial(partial), compare(compare)
+        {
+            load();
+        };
        void manage();
    private:
        string path;
        int max;
        string model;
        string scoreName;
+        bool complete;
+        bool partial;
+        bool indexList = true;
+        bool openExcel = false;
+        bool compare;
+        lxw_workbook* workbook = NULL;
        vector<Result> files;
        void load(); // Loads the list of results
        void show() const;
-        void report(const int index, const bool excelReport) const;
+        void report(const int index, const bool excelReport);
+        void showIndex(const int index, const int idx) const;
        int getIndex(const string& intent) const;
        void menu();
        void sortList();
--- a/src/Platform/main.cc
+++ b/src/Platform/main.cc
@@ -87,7 +87,7 @@ int main(int argc, char** argv)
    auto stratified = program.get<bool>("stratified");
    auto n_folds = program.get<int>("folds");
    auto seeds = program.get<vector<int>>("seeds");
-    auto hyperparameters =program.get<string>("hyperparameters");
+    auto hyperparameters = program.get<string>("hyperparameters");
    vector<string> filesToTest;
    auto datasets = platform::Datasets(path, true, platform::ARFF);
    auto title = program.get<string>("title");
@@ -102,7 +102,7 @@ int main(int argc, char** argv)
        }
        filesToTest.push_back(file_name);
    } else {
-        filesToTest = platform::Datasets(path, true, platform::ARFF).getNames();
+        filesToTest = datasets.getNames();
        saveResults = true;
    }
    /*
--- a/src/Platform/manage.cc
+++ b/src/Platform/manage.cc
@@ -12,6 +12,9 @@ argparse::ArgumentParser manageArguments(int argc, char** argv)
    program.add_argument("-n", "--number").default_value(0).help("Number of results to show (0 = all)").scan<'i', int>();
    program.add_argument("-m", "--model").default_value("any").help("Filter results of the selected model)");
    program.add_argument("-s", "--score").default_value("any").help("Filter results of the score name supplied");
+    program.add_argument("--complete").help("Show only results with all datasets").default_value(false).implicit_value(true);
+    program.add_argument("--partial").help("Show only partial results").default_value(false).implicit_value(true);
+    program.add_argument("--compare").help("Compare with best results").default_value(false).implicit_value(true);
    try {
        program.parse_args(argc, argv);
        auto number = program.get<int>("number");
@@ -20,6 +23,9 @@ argparse::ArgumentParser manageArguments(int argc, char** argv)
        }
        auto model = program.get<string>("model");
        auto score = program.get<string>("score");
+        auto complete = program.get<bool>("complete");
+        auto partial = program.get<bool>("partial");
+        auto compare = program.get<bool>("compare");
    }
    catch (const exception& err) {
        cerr << err.what() << endl;
@@ -35,7 +41,12 @@ int main(int argc, char** argv)
    auto number = program.get<int>("number");
    auto model = program.get<string>("model");
    auto score = program.get<string>("score");
-    auto results = platform::Results(platform::Paths::results(), number, model, score);
+    auto complete = program.get<bool>("complete");
+    auto partial = program.get<bool>("partial");
+    auto compare = program.get<bool>("compare");
+    if (complete)
+        partial = false;
+    auto results = platform::Results(platform::Paths::results(), number, model, score, complete, partial, compare);
    results.manage();
    return 0;
 }
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -4,6 +4,7 @@ if(ENABLE_TESTING)
    include_directories(${BayesNet_SOURCE_DIR}/src/Platform)
    include_directories(${BayesNet_SOURCE_DIR}/lib/Files)
    include_directories(${BayesNet_SOURCE_DIR}/lib/mdlp)
+    include_directories(${BayesNet_SOURCE_DIR}/lib/json/include)
    set(TEST_SOURCES BayesModels.cc BayesNetwork.cc ${BayesNet_SOURCE_DIR}/src/Platform/platformUtils.cc ${BayesNet_SOURCES})
    add_executable(${TEST_MAIN} ${TEST_SOURCES})
    target_link_libraries(${TEST_MAIN} PUBLIC "${TORCH_LIBRARIES}" ArffFiles mdlp Catch2::Catch2WithMain)
Author	SHA1	Message	Date
Ricardo Montañana Gómez	fc81730dfc	Merge pull request 'Exchange OpenXLSX to libxlsxwriter' (#8 ) from libxlsxwriter into main Add multiple sheets to excel file Add format and color to sheets Add comparison with ZeroR Add comparison with Best Results Separate contextual menu from general in manage	2023-09-20 11:17:16 +00:00
Ricardo Montañana	d8734ff082	Separate contextual menu from general	2023-09-20 13:15:33 +02:00
Ricardo Montañana	03533461c8	Add compare to best results in manage	2023-09-20 12:51:19 +02:00
Ricardo Montañana	68f22a673d	Add comparison to report console	2023-09-20 11:40:01 +02:00
Ricardo Montañana	b9bc0088f3	Add format to unique dataset results summary	2023-09-20 10:30:45 +02:00
Ricardo Montañana	c280e254ca	Remove OpenXLSX submodule	2023-09-20 01:09:58 +02:00
Ricardo Montañana	3d0f29fda3	Remove .vscode/settings.json from repository	2023-09-20 01:01:40 +02:00
Ricardo Montañana	20a6ebab7c	Support to add any number of sheets to excel	2023-09-20 00:58:01 +02:00
Ricardo Montañana	925f71166c	Fix mistake in comparison	2023-09-19 23:46:49 +02:00
Ricardo Montañana	f69f415b92	Complete comparison with ZeroR	2023-09-19 17:55:03 +02:00
Ricardo Montañana	1bdfbd1620	Complete adding color to format	2023-09-19 14:07:41 +02:00
Ricardo Montañana	06fb135526	First approach	2023-09-18 23:26:22 +02:00
Ricardo Montañana	501ea0ab4e	Fix CMakeList manage build with Linux	2023-09-18 19:27:40 +02:00
Ricardo Montañana	847c6761d7	Add Linux specific link library to cmake	2023-09-17 10:42:19 +02:00
Ricardo Montañana	6030885fc3	Add partial result filter to manage	2023-09-16 17:27:18 +02:00
Ricardo Montañana	89df7f4db0	Add library to manage link	2023-09-14 01:41:49 +02:00
Ricardo Montañana	41257ed566	If ! convergence don't predict test	2023-09-10 19:50:36 +02:00
Ricardo Montañana	506369e46b	Add Convergence hyperparameter	2023-09-07 11:27:35 +02:00
Ricardo Montañana	d908f389f5	Begin using validation as finish condition	2023-09-06 10:51:07 +02:00
Ricardo Montañana	5a7c8f1818	Add status to classifier and Experiment	2023-09-05 13:39:43 +02:00
Ricardo Montañana	64fc7bd9dd	Add show dataset detail in report	2023-09-05 09:26:49 +02:00
Ricardo Montañana	0b7beda78c	Add threads without limit to network fit	2023-09-04 21:24:11 +02:00
Ricardo Montañana	05b670dfc0	Add detail to fold progress in main	2023-09-03 16:33:48 +02:00
Ricardo Montañana	de62d42b74	Fix make debug command	2023-09-03 14:13:10 +02:00
Ricardo Montañana	edb957d22e	Add filter complete results to manage	2023-09-03 14:07:11 +02:00
Ricardo Montañana Gómez	4de5cb4c6c	Merge pull request 'Solve Ensemble models exceptions on certain datasets' (#7 ) from solveexceptions into main Reviewed-on: #7	2023-09-02 15:29:33 +00:00