Add selector in maint_interface

- Sorting strategy and Enum strategy moved as list_heuristic class parameters

CMakeLists.txt

@@ -33,6 +33,7 @@ add_executable(pdptw src/mains/main.cpp
                 src/lns/modification/route/insert_route_with_pair.cpp
                 src/lns/modification/route/insert_route.cpp
                 src/lns/modification/route/remove_route.cpp
+                src/output/lns_output.cpp
                 src/output/solution_checker.cpp
                 src/output/solution_exporter.cpp
                 src/lns/operators/sorting_strategy.cpp
@@ -42,6 +43,7 @@ add_executable(pdptw src/mains/main.cpp
                 src/lns/operators/reconstruction/list_heuristic_cost_oriented.cpp
                 src/lns/operators/selector/operator_selector.cpp
                 src/lns/operators/selector/small_large_selector.cpp
+                src/lns/lns.cpp
                 src/utils.cpp
                 )
 

src/input/pdptw_data.cpp

@@ -78,6 +78,12 @@ const Pair &PDPTWData::getPair(int id) const
     throw std::runtime_error("Pair not found");
 }
 
+int PDPTWData::getPairCount() const
+{
+    return getPairs().size();
+}
+
+
 void PDPTWData::print() const 
 {
     std::cout << "Instance name : " << dataName << "\n";

src/input/pdptw_data.h

 #pragma once
 
-#include <nlohmann/json_fwd.hpp>
-#include <vector>
-
-#include "pair.h"
 #include "location.h"
+#include "pair.h"
 #include "types.h"
 
+#include <nlohmann/json_fwd.hpp>
+#include <vector>
+
 using json = nlohmann::json;
 
 /**
@@ -43,7 +43,8 @@ public:
      * Constructs an empty PDPTWData.
      * @see parsing::parseJson
      */
-    PDPTWData(std::string dataName, int size, int capacity, Location depot, std::vector<Location> locations, Matrix distanceMatrix);
+    PDPTWData(std::string dataName, int size, int capacity, Location depot, std::vector<Location> locations,
+              Matrix distanceMatrix);
     /**
      * Checks some data coherence
      */
@@ -54,8 +55,8 @@ public:
 
     std::vector<Location> const &getLocations() const;
     std::vector<Pair> const &getPairs() const;
-
-    const Pair &getPair(int id) const;
+    int getPairCount() const;
+    Pair const &getPair(int id) const;
 
     /** 
     *   0 return the depot.

src/lns/lns.cpp

+#include "lns.h"
+
+output::LnsOutput runLns(Solution const &initialSolution, OperatorSelector &opSelector, AcceptanceFunction const &acceptFunctor)
+{
+
+    // TO DO
+
+
+    //auto result = output::LnsOutput(std::move(runtime.bestSolution), runtime.numberOfIteration, getTimeSinceInSec(runtime.start));
+    //return result;
+}
\ No newline at end of file

src/lns/lns.h

+#pragma once
+
+#include "output/lns_output.h"
+
+class Solution;
+class OperatorSelector;
+class AcceptanceFunction;
+
+namespace lns
+{
+    /**
+     * @param initialSolution must be a valid solution !
+     */
+    output::LnsOutput runLns(Solution const &initialSolution, OperatorSelector &opSelector, AcceptanceFunction const &acceptFunctor);
+}// namespace lns
\ No newline at end of file

src/lns/operators/abstract_operator.h

@@ -15,6 +15,6 @@ public:
 class ReconstructionOperator
 {
 public:
-    virtual void reconstructSolution(Solution &solution, double blinkRate, SortingStrategyType strategy, EnumerationType enumeration) const = 0;
+    virtual void reconstructSolution(Solution &solution, double blinkRate) const = 0;
     virtual ~ReconstructionOperator() = default;
 };

src/lns/operators/reconstruction/list_heuristic_cost_oriented.cpp

 #include "list_heuristic_cost_oriented.h"
 
-void ListHeuristicCostOriented::reconstructSolution(Solution &solution, double blinkRate, SortingStrategyType strategy,
-                                                    EnumerationType enumeration) const
+ListHeuristicCostOriented::ListHeuristicCostOriented(SortingStrategyType strategy, EnumerationType enumeration)
+    : strategy(strategy), enumeration(enumeration)
+{}
+
+void ListHeuristicCostOriented::reconstructSolution(Solution &solution, double blinkRate) const
 {
     std::vector<int> sortedPairs;
     // selection strategy

src/lns/operators/reconstruction/list_heuristic_cost_oriented.h

@@ -11,10 +11,15 @@
  */
 class ListHeuristicCostOriented : public ReconstructionOperator
 {
+private:
+SortingStrategyType strategy;
+EnumerationType enumeration;
+
 public:
     using AtomicRecreationPtr = std::unique_ptr<AtomicRecreation>;
-    void reconstructSolution(Solution &solution, double blinkRate, SortingStrategyType strategy,
-                             EnumerationType enumeration) const override;
+
+    ListHeuristicCostOriented(SortingStrategyType strategy, EnumerationType enumeration);
+    void reconstructSolution(Solution &solution, double blinkRate) const override;
 };
 
 /**

src/lns/operators/reconstruction/list_heuristic_insertion.cpp

@@ -7,9 +7,11 @@
 #include <concepts>
 
 
-ListHeuristicInsertion::ListHeuristicInsertion() = default;
+ListHeuristicInsertion::ListHeuristicInsertion(SortingStrategyType strategy, EnumerationType enumeration)
+    : strategy(strategy), enumeration(enumeration)
+{}
 
-void ListHeuristicInsertion::reconstructSolution(Solution &solution, double blinkRate, SortingStrategyType strategy, EnumerationType enumeration) const
+void ListHeuristicInsertion::reconstructSolution(Solution &solution, double blinkRate) const
 {
     std::vector<int> sortedPairs;
     // selection strategy

src/lns/operators/reconstruction/list_heuristic_insertion.h

@@ -22,10 +22,11 @@ private:
     using AtomicRecreationPtr = std::unique_ptr<AtomicRecreation>;
 
 public:
-    explicit ListHeuristicInsertion();
+    explicit ListHeuristicInsertion(SortingStrategyType strategy, EnumerationType enumeration);
 
-    void reconstructSolution(Solution &solution, double blinkRate, SortingStrategyType strategy,
-                             EnumerationType enumeration) const override;
+    SortingStrategyType strategy; 
+    EnumerationType enumeration;
+    void reconstructSolution(Solution &solution, double blinkRate) const override;
 
 private:
     /**

src/mains/main.cpp

@@ -16,6 +16,8 @@
 #include "lns/constraints/time_window/time_window_constraint.h"
 #include "lns/operators/destruction/random_destroy.h"
 #include "lns/operators/reconstruction/list_heuristic_cost_oriented.h"
+#include "lns/operators/selector/operator_selector.h"
+#include "lns/operators/selector/small_large_selector.h"
 #include "lns/solution/solution.h"
 #include "lns/modification/pair/insert_pair.h"
 #include "lns/modification/route/insert_route.h"
@@ -27,30 +29,57 @@
 
 #include "lns/operators/reconstruction/enumerate.h"
 
+#include "mains/main_interface.h"
 #include "output/solution_exporter.h"
 
 using json = nlohmann::json;
 
-void printForwardList(const std::forward_list<std::unique_ptr<AtomicRecreation>>& list) {
-    int cpt = 1;
-    for (const auto& item : list) {
-        std::cout << cpt << "{ \n";
-        // Affichage de l'emplacement ajouté à la solution
-        int pair = item->getAddedPairs();
-        if (pair > 0) {
-            std::cout << "Added Location ID: \n";
-            std::cout << pair << "\n";
-        } else {
-            std::cout << "No location added.\n";
-        }
-        std::cout << "} \n";
-        ++cpt;
-    }
+void simpleLNS(PDPTWData const &data, Solution &startingSolution)
+{
+    // lns parameters
+    int requests = data.getPairCount();
+
+    int pairs = requests * 2 / 100;
+    int manyPairs = requests * 40 / 100;
+
+    // threshold function to do
+
+
+    // lns operators
+    SimpleOperatorSelector smallSelector;
+    addAllReconstructor(smallSelector);
+    smallSelector.addDestructor(RandomDestroy(pairs));
+
+    SimpleOperatorSelector largeSelector;
+    addAllReconstructor(largeSelector);
+    largeSelector.addDestructor(RandomDestroy(pairs));
+
+    SimpleOperatorSelector veryLargeSelector;
+    addAllReconstructor(veryLargeSelector);
+    veryLargeSelector.addDestructor(RandomDestroy(pairs));
+
+    SimpleOperatorSelector hugeSelector;
+    addAllReconstructor(hugeSelector);
+    hugeSelector.addDestructor(RandomDestroy(pairs));
+
+    SimpleOperatorSelector lastSelector;
+    addAllReconstructor(lastSelector);
+    lastSelector.addDestructor(RandomDestroy(manyPairs));
+
+    std::vector<SmallLargeOperatorSelector::StepSelector> selectors;
+    selectors.emplace_back(500, std::move(smallSelector));
+    selectors.emplace_back(1000, std::move(largeSelector));
+    selectors.emplace_back(1000, std::move(veryLargeSelector));
+    selectors.emplace_back(3000, std::move(hugeSelector));
+    selectors.emplace_back(1, std::move(lastSelector));
+    SmallLargeOperatorSelector smallLargeSelector(std::move(selectors));
+
+    // run lns
+    //lns::runLns(startingSolution, smallLargeSelector, acceptor);
 }
 
 int main(int argc, char const *argv[])
 {
-    //std::string filepath = "/home/a24jacqb/Documents/Code/pdptw-main/data_in/test_inst.json"; 
     //std::string filepath = "/home/a24jacqb/Documents/Code/pdptw-main/data_in/n100/bar-n100-1.json";
     std::string filepath = "/home/a24jacqb/Documents/Code/pdptw-main/data_in/Nantes_1.json";
     //std::string filepath = "/home/a24jacqb/Documents/Code/pdptw-main/data_in/n5000/bar-n5000-1.json";
@@ -62,9 +91,6 @@ int main(int argc, char const *argv[])
 
     // std::cout << filepath << "\n";
 
-    // PDPTWData data = parsing::parseJson(filepath);
-    // data.checkData();
-
     // data.print();
     
     // std::cout << " \n";

src/mains/main_interface.cpp

@@ -6,6 +6,11 @@
 #include <nlohmann/json.hpp>
 #include <spdlog/spdlog.h>
 
+void addAllReconstructor(SimpleOperatorSelector &selector)
+{
+    selector.addReconstructor(ListHeuristicCostOriented(SortingStrategyType::SHUFFLE, EnumerationType::ALL_INSERT_PAIR));
+}
+
 int mainInterface(int argc, char **argv, std::function<void(PDPTWData &, Solution &)> function)
 {
 

src/mains/main_interface.h

 #pragma once
 
 #include "input/pdptw_data.h"
+#include "lns/operators/reconstruction/list_heuristic_cost_oriented.h"
+#include "lns/operators/selector/operator_selector.h"
 #include "lns/solution/solution.h"
 
 #include <functional>
 
+void addAllReconstructor(SimpleOperatorSelector &selector);
 int mainInterface(int argc, char **argv, std::function<void(PDPTWData &, Solution &)> function);
+

src/output/lns_output.cpp

+#include "lns_output.h"
+
+#include "output/solution_exporter.h"
+
+unsigned int output::LnsOutput::getNumberOfIteration() const
+{
+    return numberOfIteration;
+}
+
+Solution const &output::LnsOutput::getBestSolution() const
+{
+    return bestSolution;
+}
+
+unsigned long output::LnsOutput::getTimeSpent() const
+{
+    return timeSpent;
+}
+
+output::LnsOutput::LnsOutput(Solution &&bestSolution, unsigned int numberOfIteration, unsigned long timeSpent)
+    : bestSolution(std::move(bestSolution)), numberOfIteration(numberOfIteration), timeSpent(timeSpent)
+{}
+
+void output::LnsOutput::writeSolutionToFile() const
+{
+    output::exportToJson(getBestSolution());
+}
\ No newline at end of file

src/output/lns_output.h

+#pragma once
+
+#include "lns/solution/solution.h"
+
+namespace output
+{
+    class LnsOutput
+    {
+        Solution bestSolution;
+        unsigned int numberOfIteration;
+        unsigned long timeSpent;
+
+    public:
+        LnsOutput(Solution &&bestSolution, unsigned int numberOfIteration, unsigned long timeSpent);
+        unsigned int getNumberOfIteration() const;
+        Solution const &getBestSolution() const;
+        unsigned long getTimeSpent() const;
+        void writeSolutionToFile() const;
+    };
+}// namespace output
\ No newline at end of file

src/output/solution_checker.cpp

@@ -57,7 +57,6 @@ void checker::checkSolutionCoherence(Solution const &sol, PDPTWData const &data)
     std::cout << "#";
 
     // checking PairBank coherence (given the routes)
-    std::vector<int> testbank = sol.getBank();
     for (int pairID: sol.getBank())
     {
         // check goes from 0 et n-1