Skip to content
Snippets Groups Projects
Select Git revision
  • 62835d4d651fb4d273820d4432211caca359aa81
  • master default protected
2 results

quebec.cpp

Blame
  • quebec.cpp 5.50 KiB
    #include <filesystem>
    #include <fstream>
    #include <iostream>
    
    #include "indices/eca.hpp"
    #include "landscape/decored_landscape.hpp"
    
    #include "solvers/pl_eca_2.hpp"
    #include "solvers/pl_eca_3.hpp"
    
    #include "helper.hpp"
    #include "instances_helper.hpp"
    #include "print_helper.hpp"
    
    template <typename T>
    double eval(T && ls) {
        const ECA & eca = ECA();
        return eca.eval(ls);
    }
    
    int main() {
        std::ofstream data_log("output/time_quebec.csv");
        data_log << std::fixed << std::setprecision(6);
        data_log << "budget,budget_percent,base_ECA,max_delta_ECA,pl_eca_2_ECA,pl_"
                    "eca_2_obj,pl_eca_2_variables,pl_2_constraints,pl_2_entries,pl_"
                    "2_time,pl_eca_3_ECA,pl_eca_3_obj,pl_eca_3_variables,pl_3_"
                    "constraints,pl_3_entries,pl_3_preprocessing_time,pl_3_time"
                 << std::endl;
    
        std::vector<double> budget_percents;
        for(int i = 31; i <= 40; ++i) budget_percents.push_back(i);
    
        Solvers::PL_ECA_2 pl_eca_2;
        pl_eca_2.setTimeout(36000).setLogLevel(2);
        Solvers::PL_ECA_3 pl_eca_3;
        pl_eca_3.setTimeout(36000).setLogLevel(2);
    
        const double median = 300;
        Instance instance = make_instance_quebec_frog(1, 0, median);
        instance.plan.initElementIDs();
        const MutableLandscape & landscape = instance.landscape;
        const RestorationPlan<MutableLandscape> & plan = instance.plan;
    
        std::cout << "median:" << median << std::endl;
        std::cout << "nb nodes:" << lemon::countNodes(landscape.getNetwork())
                  << std::endl;
        std::cout << "nb arcs:" << lemon::countArcs(landscape.getNetwork())
                  << std::endl;
        std::cout << "nb options:" << plan.getNbOptions() << std::endl;
        std::cout << "nb restorable arcs:" << plan.getNbArcRestorationElements()
                  << std::endl;
        std::cout << "plan total cost:" << plan.totalCost() << std::endl;
    
        // Helper::printInstanceGraphviz(landscape, plan, "quebec.dot");
        // Helper::printInstance(landscape, plan, "quebec.eps");
    
        
        for(double budget_percent : budget_percents) {
            const double B = plan.totalCost() * budget_percent / 100;
    
            const double base_ECA = eval(landscape);
            const double restored_ECA =
                eval(Helper::decore_landscape(landscape, plan));
            const double max_delta_ECA = restored_ECA - base_ECA;
    
            Solution pl_2_solution = pl_eca_2.solve(landscape, plan, B);
            Solution pl_3_solution = pl_eca_3.solve(landscape, plan, B);
    
            const double pl_2_ECA =
                eval(Helper::decore_landscape(landscape, plan, pl_2_solution));
            const double pl_3_ECA =
                eval(Helper::decore_landscape(landscape, plan, pl_3_solution));
    
            data_log << B << ',' << budget_percent << ',' << base_ECA << ','
                     << max_delta_ECA << ',' << pl_2_ECA << ',' << pl_2_solution.obj
                     << ',' << pl_2_solution.nb_vars << ','
                     << pl_2_solution.nb_constraints << ','
                     << pl_2_solution.nb_elems << ','
                     << pl_2_solution.getComputeTimeMs() << ',' << pl_3_ECA << ','
                     << pl_3_solution.obj << ',' << pl_3_solution.nb_vars << ','
                     << pl_3_solution.nb_constraints << ','
                     << pl_3_solution.nb_elems << ','
                     << pl_3_solution.preprocessing_time << ','
                     << pl_3_solution.getComputeTimeMs() << std::endl;
        }
    
        return EXIT_SUCCESS;
    }
    
    // #include <filesystem>
    // #include <fstream>
    // #include <iostream>
    
    // #include "indices/eca.hpp"
    // #include "landscape/decored_landscape.hpp"
    
    // #include "solvers/bogo.hpp"
    // #include "solvers/glutton_eca_dec.hpp"
    // #include "solvers/glutton_eca_inc.hpp"
    // #include "solvers/pl_eca_3.hpp"
    
    // #include "helper.hpp"
    // #include "instances_helper.hpp"
    // #include "print_helper.hpp"
    
    // int main() {
    //     std::ofstream data_log("output/quebec_analysis.csv");
    //     data_log << std::fixed << std::setprecision(6);
    //     data_log <<
    //     "median_dist,90_eca_node_cover,90_eca_node_cover_restored,base_"
    //                 "ECA,delta_ECA"
    //              << std::endl;
    
    //     std::vector<double> median_dists{1000, 1500, 2000, 2500, 3000, 3500};
    //     std::vector<double> decreased_probs{0};
    
    //     const ECA & eca = ECA();
    
    //     for(double median : median_dists) {
    //         Instance instance = make_instance_quebec_frog(1, 0, median);
    //         const MutableLandscape & landscape = instance.landscape;
    //         const RestorationPlan<MutableLandscape> & plan = instance.plan;
    
    //         std::cout << lemon::countNodes(landscape.getNetwork()) << std::endl;
    
    //         Helper::assert_well_formed(landscape, plan);
    //         Helper::printInstanceGraphviz(landscape, plan, "quebec.dot");
    
    //         auto restored_landscape = Helper::decore_landscape(landscape, plan);
    
    //         const double eca_90_node_cover =
    //             Helper::averageRatioOfNodesInECARealization(0.90, landscape);
    //         const double eca_90_node_cover_restored =
    //             Helper::averageRatioOfNodesInECARealization(0.90,
    //                                                         restored_landscape);
    
    //         const double base_ECA = ECA().eval(landscape);
    //         const double restored_ECA =
    //             ECA().eval(Helper::decore_landscape(landscape, plan));
    //         const double delta_ECA = restored_ECA - base_ECA;
    
    //         data_log << median << ',' << eca_90_node_cover * 100 << ','
    //                  << eca_90_node_cover_restored * 100 << ',' << base_ECA <<
    //                  ','
    //                  << delta_ECA << std::endl;
    //     }
    
    //     return EXIT_SUCCESS;
    // }