Fix some issues

- init the solution with one empty road
- fix bug while init Data
- some tests in the main

CMakeLists.txt

@@ -36,8 +36,9 @@ add_executable(pdptw src/mains/main.cpp
                 src/output/solution_checker.cpp
                 src/lns/operators/sorting_strategy.cpp
                 src/lns/operators/destruction/random_destroy.cpp
-                src/lns/operators/generation/enumerate.cpp 
-                src/lns/operators/generation/modification_generator.cpp 
+                src/lns/operators/generators/enumerate.cpp 
+                src/lns/operators/generators/modification_generator.cpp 
+                src/lns/operators/reconstruction/list_heuristic_insertion.hpp
                 src/lns/operators/selector/operator_selection.cpp
                 src/utils.cpp
                 )

src/config.h

@@ -2,4 +2,4 @@
 
 const int EXCLUSION_PENALTY = 100;
 
-const int RANDOM_SEED = 10;
\ No newline at end of file
+const int RANDOM_SEED = 100;
\ No newline at end of file

src/input/data.cpp

@@ -26,8 +26,12 @@ double data::routeCost(PDPTWData const & data, Route const & route)
     const std::vector<int> & routeIDs = route.getRoute();
     double cost = 0;
 
+    if (routeIDs.empty())
+    {
+        return 0;
+    }
     // cost from and to the depot
-    cost +=  matrix[0][routeIDs[0]];
+    cost +=  matrix[0][routeIDs.at(0)];
     //std::cout << "\n route cost : " << matrix[0][routeIDs[0]] << " ";
     cost +=  matrix[routeIDs.back()][0];
     

src/input/location.cpp

@@ -51,6 +51,6 @@ void Location::print() const
 {
     std::cout << "Location ID: " << id << ", Coordinates: (" << longitude << ", " << latitude << ")\n";
     std::cout << "Location Type : " <<  Location::LocTypeToString(locType) << ", Associated location : " << pairedLocationID << "\n";
-    std::cout << "Demand : " <<  demand << "\n";
+    std::cout << "Demand : " <<  demand << ", Service Duration :" << serviceDuration << "\n";
     timeWindow.print();
 }
\ No newline at end of file

src/input/pdptw_data.cpp

@@ -55,7 +55,7 @@ PDPTWData::PDPTWData(int size, int capacity, Location depot, std::vector<Locatio
         if( loc.getLocType() == LocType::PICKUP )
         {
             // vector indexed from 0 / Location indexed from 1
-            pairs.emplace_back(loc, locations[loc.getPair()-1], loc.getId());
+            pairs.emplace_back(loc, this->locations[loc.getPair()-1], loc.getId());
         }
     }
 }

src/lns/constraints/capacity/capacity_constraint.cpp

@@ -67,7 +67,7 @@ bool CapacityConstraint::checkModif(Pair const &pair, int routeIndex, int Pickup
 // not ideal
 void CapacityConstraint::applyModif(Pair const &pair, int routeIndex, int PickupPosition,  int DeliveryPosition, bool addPair)
 {
-    std::cout << "ok \n";
+    std::cout << "ApplyModif (capa constraint) \n";
     if (addPair)
     {   
         // Insert new values
@@ -104,6 +104,7 @@ void CapacityConstraint::applyModif(Pair const &pair, int routeIndex, int Pickup
 
 bool CapacityConstraint::check(InsertPair const &op) const
 {
+    std::cout << "capa constraint \n";
     return checkModif(op.getPair(), op.getRouteIndex(), op.getPickupInsertion(), op.getDeliveryInsertion());
 }
 void CapacityConstraint::apply(InsertPair const &op)

src/lns/constraints/time_window/time_window_constraint.cpp

@@ -63,6 +63,7 @@ void TimeWindowConstraint::initReachTimes()
 // refait l'ordo sur le nouveau vecteur
 bool TimeWindowConstraint::checkInsertion(const PDPTWData& data, const Pair & pair, int routeIndex, int pickupPos, int deliveryPos) const
 {
+
     ReachTimeVector const &reachTimes = allRouteReachTimes.at(routeIndex);
 
     // COPY route vector
@@ -75,22 +76,22 @@ bool TimeWindowConstraint::checkInsertion(const PDPTWData& data, const Pair & pa
     route.insert(route.begin() + pickupPos, pair.getPickup().getId());
     
 
-    std::cout << "\n";
-    for (auto pos : route)
-    {
-        std::cout << pos << " ";
-    }
-    std::cout << "\n";
+    // std::cout << "\n";
+    // for (auto pos : route)
+    // {
+    //     std::cout << pos << " ";
+    // }
+    // std::cout << "\n";
 
     // Compute new reach time
     computeReachTimes(data, route, newReachTimes);
 
-    std::cout << "\n";
-    for (auto pos : newReachTimes)
-    {
-        std::cout << pos << " ";
-    }
-    std::cout << "\n";
+    // std::cout << "\n";
+    // for (auto pos : newReachTimes)
+    // {
+    //     std::cout << pos << " ";
+    // }
+    // std::cout << "\n";
 
     // Check Time Windows
     for (int i = 0; i < newReachTimes.size(); ++i) 
@@ -137,6 +138,7 @@ void TimeWindowConstraint::ApplyModif(const PDPTWData& data, const Pair & pair,
 
 bool TimeWindowConstraint::check(InsertPair const &op) const
 {
+    std::cout << "tw constraint \n";
     return checkInsertion(getSolution().getData(), op.getPair(), op.getRouteIndex(), op.getPickupInsertion(), op.getDeliveryInsertion()); 
 }
 void TimeWindowConstraint::apply(InsertPair const &op)

src/lns/modification/atomic_recreation.h

 #pragma once
 
 #include "atomic_modification.h"
+#include "input/pair.h"
 
 class Location;
 
@@ -20,7 +21,8 @@ public:
     virtual ModificationCheckVariant asCheckVariant() const = 0;
     
     /**
-     * @return the pickup location added to the solution, nullptr if none were added
+     * @return the pair added to the solution, nullptr if none were added
+     * (why return pointer and not juste a int ?)
      */
-    virtual Location const *getAddedLocation() const = 0;
+    virtual Pair const *getAddedPairs() const = 0;
 };
\ No newline at end of file

src/lns/modification/pair/insert_pair.cpp

 #include "insert_pair.h"
 #include "input/data.h"
+#include "lns/constraints/constraint.h"
 
 
 InsertPair::InsertPair(int routeIndex, int pickupInsertion, int deliveryInsertion, Pair const &pair) : 
@@ -87,9 +88,9 @@ const Location &InsertPair::getDeliveryLocation() const
     return deliveryLocation;
 }
 
-const Location *InsertPair::getAddedLocation() const 
+const Pair *InsertPair::getAddedPairs() const 
 {
-    return &pickupLocation;
+    return &pair;
 }
 
 const Pair &InsertPair::getPair() const 

src/lns/modification/pair/insert_pair.h

@@ -55,7 +55,7 @@ public:
     
     void modifySolution(Solution &solution) override;
     double evaluate(Solution const &solution) const override;
-    Location const *getAddedLocation() const override;
+    Pair const *getAddedPairs() const override;
 
     int getPickupInsertion() const;
     int getDeliveryInsertion() const;

src/lns/modification/route/insert_route.cpp

@@ -14,7 +14,7 @@ double InsertRoute::evaluate(Solution const &solution) const
     return 0;
 }
 
-Location const *InsertRoute::getAddedLocation() const
+Pair const *InsertRoute::getAddedPairs() const
 {
     return nullptr;
 }

src/lns/modification/route/insert_route.h

@@ -16,7 +16,7 @@ public:
 
     void modifySolution(Solution &solution) override;
     double evaluate(Solution const &solution) const override;
-    Location const *getAddedLocation() const override;
+    Pair const *getAddedPairs() const override;
 
     ModificationCheckVariant asCheckVariant() const override;
 };  
\ No newline at end of file

src/lns/operators/generators/enumerate.cpp

@@ -14,19 +14,19 @@ namespace enumeration
                                 std::function<void(InsertPair &&)> const &consumeModification)
     {
         int routeIndex = 0;
-        for (const Route &route : solution.getRoutes())
+        // Insert into existing routes
+        for (Route const &route: solution.getRoutes())
         {
             for (int p = 0; p <= route.getSize(); p++)
             {
                 for (int d = p; d <= route.getSize(); d++)
                 {
                     Index index = std::make_tuple(routeIndex, p, d);
+                    //std::cout << std::get<0>(index) << " " <<  std::get<1>(index) << " " << std::get<2>(index) << "\n";
                     consumeModification(InsertPair(index, pair));
                 }
             }
             ++routeIndex;
         }
     }
-
-
 }// namespace enumeration
\ No newline at end of file

src/lns/operators/generators/modification_generator.cpp

@@ -15,19 +15,23 @@ namespace generator
     std::function<void(ModificationType &&)> addToListIfValidTemplate(Solution const &solution,
                                                                       ModificationContainer &list)
     {
+        std::cout << "avant error \n";
         return [&](ModificationType &&modification) {
+            std::cout << "Check Modif \n";
             if (solution.checkModification(modification))
             {
+                std::cout << "insert modif to list \n";
                 list.push_front(std::make_unique<ModificationType>(modification));
             }
         };
     }
 
-    void AllTypedModifications<InsertPair>::populate(Solution const &solution, Pair const &request,
+    void AllTypedModifications<InsertPair>::populate(Solution const &solution, Pair const &pair,
                                                      std::forward_list<std::unique_ptr<AtomicRecreation>> &list)
     {
+        std::cout << "dans modif_generator \n";
         enumeration::enumerateAllInsertPair(
-                solution, request, addToListIfValidTemplate<InsertPair>(solution, list));
+                solution, pair, addToListIfValidTemplate<InsertPair>(solution, list));
     }
 
 }// namespace generator

src/lns/operators/reconstruction/list_heuristic_insertion.hpp

@@ -17,7 +17,7 @@ template<std::derived_from<sorting_strategy::SortingStrategy> Strategy,
          std::derived_from<generator::ModificationGenerator> Generator>
 void ListHeuristicInsertion<Strategy, Generator>::reconstructSolution(Solution &solution, double blinkRate) const
 {
-    std::vector<int> sortedPairs = Strategy(solution).sortRequests();
+    std::vector<int> sortedPairs = Strategy(solution).sortPairs();
     AtomicRecreationPtr recreation;
     for (int pairID: sortedPairs)
     {
@@ -25,6 +25,7 @@ void ListHeuristicInsertion<Strategy, Generator>::reconstructSolution(Solution &
         recreation = ListHeuristicInsertion::choosingStrategy(solution, pair, blinkRate);
         if (recreation)
         {
+            std::cout << "\n apply recreation "<< " " << "\n \n";
             solution.applyRecreateSolution(*recreation);
         }
     }
@@ -43,7 +44,7 @@ std::unique_ptr<AtomicRecreation> ListHeuristicInsertion<Strategy, Generator>::c
     Generator().populate(solution, pair, modifications);
     for (AtomicRecreationPtr &possibleRecreation: modifications)
     {
-        if (util::getRandom() < 1 - blinkRate)
+        if (util::getRandom() <= 1 - blinkRate)
         {
             double newInsertionCost = possibleRecreation->evaluate(solution);
             if (newInsertionCost < bestKnownInsertionCost)

src/lns/solution/solution.cpp

@@ -21,6 +21,7 @@ void Solution::initPairBank()
 void Solution::initRoutes()
 {
     routes.clear();
+    routes.emplace_back();
 }
 
 void Solution::initConstraints()
@@ -45,7 +46,6 @@ double Solution::computeSolutionCost() const
     {
         cost += data::routeCost(data, route);
     }
-    std::cout << "le cout " << cost << " \n";
     return cost;
 }
 
@@ -130,7 +130,7 @@ double Solution::getCost() const
 
 PDPTWData const &Solution::getData() const
 {
-    return data;
+    return data.get();
 }
 
 int Solution::requestsFulFilledCount() const
@@ -149,12 +149,15 @@ bool Solution::checkModification(AtomicRecreation const &modification) const
     // visitor pattern
     for (std::unique_ptr<Constraint> const &constraint: constraints)
     {
+        std::cout << "in check modif \n";
         if (!constraint->checkVariant(checkVariant))
         {
+            std::cout << "return false \n";
             return false;
         }
     }
     return true; 
+    std::cout << "return true \n";
 }
 
 
@@ -175,7 +178,7 @@ void Solution::afterApplyModification(AtomicModification &modification)
 void Solution::applyRecreateSolution(AtomicRecreation &modification)
 {
     // apply the modification to the solution
-    
+    std::cout << "not fonctionnal yet \n";
 }
 
 void Solution::applyDestructSolution(AtomicDestruction &modification)

src/lns/solution/solution.h

 #pragma once
 
 #include "input/pair.h"
+#include "input/pdptw_data.h"
 #include "lns/constraints/constraint.h"
 #include "route.h"
 
@@ -23,8 +24,8 @@ public:
     using PairBank = std::vector<int>;
 
 private:
-    // ref_wrapper
-    PDPTWData const &data;
+    std::reference_wrapper<PDPTWData const> data;
+    //PDPTWData const &data;
     /*
      *  Store IDs of a pairs (Pickup & Delivery) that are not assigned yet to a route.
      */
@@ -40,6 +41,7 @@ private:
 public:
     /**
      *  Expected way to construct a solution.
+     *  Generate an empty solution with all pairs in the pairBank and one empty route.
      */
     static Solution emptySolution(PDPTWData const &data);
 

src/mains/main.cpp

@@ -8,6 +8,7 @@
 #include <spdlog/spdlog.h>
 
 #include "input/location.h"
+#include "input/pdptw_data.h"
 #include "input/time_window.h"
 #include "input/json_parser.h"
 #include "input/data.h"
@@ -19,8 +20,31 @@
 #include "lns/modification/pair/remove_pair.h"
 #include "lns/modification/route/remove_route.h"
 
+#include "lns/operators/reconstruction/list_heuristic_insertion.h"
+#include "lns/operators/reconstruction/list_heuristic_insertion.hpp"
+#include "lns/operators/generators/modification_generator.h"
+#include "lns/operators/sorting_strategy.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
+        const Pair* pair = item->getAddedPairs();
+        if (pair != nullptr) {
+            std::cout << "Added Location ID: \n";
+            pair->print();
+        } else {
+            std::cout << "No location added.\n";
+        }
+        std::cout << "} \n";
+        ++cpt;
+    }
+}
+
 int main(int argc, char const *argv[])
 {
     //std::string filepath = "/home/a24jacqb/Documents/Code/pdptw-main/data_in/test_inst.json"; 
@@ -39,8 +63,53 @@ int main(int argc, char const *argv[])
     /* 
     * test 
     */
-    Solution emptySol = Solution::emptySolution(data);
-    emptySol.print();
+    Solution solution = Solution::emptySolution(data);
+
+    std::cout << "--- Empty Solution --- \n";
+    solution.print();
+
+    sorting_strategy::Shuffle shuffleStrategy(solution);  // Créer une instance de la stratégie de tri
+    auto sortedPairs = shuffleStrategy.sortPairs();
+
+    for (auto id : sortedPairs)
+    {
+        std::cout << id << " ";
+    }
+    std::cout << "\n";
+    // ListHeuristicInsertion<sorting_strategy::SortingStrategy, generator::ModificationGenerator> operator;
+
+    // double blinkRate = 0.1; // Par exemple, 10% de probabilité d'ignorer l'insertion
+    // operator.reconstructSolution(emptySol, blinkRate);
+
+    std::cout << "---- \n";
+
+    generator::AllTypedModifications<InsertPair> generator;
+    generator::ModificationContainer modificationList;
+    
+   
+    std::cout << "---- \n";
+
+    int pairID = solution.getBank().front();
+    Pair pair = solution.getData().getPair(pairID);
+
+    pair.print();
+
+    std::cout << "---- \n";
+    generator.populate(solution, pair, modificationList); 
+
+    // print the pair associated to each modif
+    printForwardList(modificationList);
+    
+    std::cout << "\n ---- \n \n";
+    //ListHeuristicInsertion<std::derived_from<sorting_strategy::SortingStrategy> Strategy, std::derived_from<generator::ModificationGenerator> Generator>
+
+    double blinkRate = 0;
+
+    //operator.reconstructSolution(solution, blinkRate);
+    ListHeuristicInsertion<sorting_strategy::Shuffle, generator::AllTypedModifications<InsertPair>> operatorInstance;
+
+    operatorInstance.reconstructSolution(solution, blinkRate);
 
+    solution.print();
     return 0;
 }