Update extern/solver subproject commit hash and enhance executor functionality with new delay methods

Author: riccardodebenedictis

extern/solver

@@ -60,15 +60,15 @@ namespace ratio::executor
      *
      * @param atoms The set of atoms which are not yet ready to start and the corresponding delay time.
      */
-    void dont_start_yet(const std::unordered_map<const riddle::atom_term *, utils::rational> &atoms) { dont_start.insert(atoms.cbegin(), atoms.cend()); }
+    void dont_start_yet(const std::unordered_map<riddle::atom_term *, utils::rational> &atoms);
     /**
      * @brief Inserts the given atoms into the `dont_end` unordered map.
      *
      * This function inserts the given atoms into the `dont_end` set, which contains the atoms that are not yet ready to end. The solver will adapt the plan to delay the ending of these atoms.
      *
      * @param atoms The set of atoms which are not yet ready to end and the corresponding delay time.
      */
-    void dont_end_yet(const std::unordered_map<const riddle::atom_term *, utils::rational> &atoms) { dont_end.insert(atoms.cbegin(), atoms.cend()); }
+    void dont_end_yet(const std::unordered_map<riddle::atom_term *, utils::rational> &atoms);
     /**
      * @brief Notifies the executor that the given atoms have failed.
      *
@@ -86,6 +86,8 @@ namespace ratio::executor
   private:
     virtual void adapt() = 0;
 
+    virtual void delay(riddle::arith_expr tp, const utils::rational &d) = 0;
+
   private:
     /**
      * @brief Called when the state of the executor changes.
@@ -134,15 +136,13 @@ namespace ratio::executor
   protected:
     std::mutex mtx; // the mutex for the critical sections..
   private:
-    std::atomic<bool> running = false;                                                                                   // the running state..
-    executor_state state = executor_state::Reasoning;                                                                    // the current state of the executor..
-    std::unordered_set<const riddle::predicate *> executable_predicates;                                                 // the set of executable (impulses and intervals) predicates..
-    const utils::rational units_per_tick;                                                                                // the number of plan units for each tick..
-    bool pending_requirements = false;                                                                                   // whether there are pending requirements to be solved or not..
-    utils::rational current_time;                                                                                        // the current time in plan units..
-    std::unordered_set<const riddle::atom_term *> executing;                                                             // the atoms that are currently executing..
-    std::unordered_map<const riddle::atom_term *, utils::rational> dont_start;                                           // the starting atoms which are not yet ready to start..
-    std::unordered_map<const riddle::atom_term *, utils::rational> dont_end;                                             // the ending atoms which are not yet ready to end..
-    std::map<utils::inf_rational, std::pair<std::vector<riddle::atom_term *>, std::vector<riddle::atom_term *>>> pulses; // the pulses of the executor, with the starting and ending atoms..
+    std::atomic<bool> running = false;                                                                                                 // the running state..
+    executor_state state = executor_state::Reasoning;                                                                                  // the current state of the executor..
+    std::unordered_set<const riddle::predicate *> executable_predicates;                                                               // the set of executable (impulses and intervals) predicates..
+    const utils::rational units_per_tick;                                                                                              // the number of plan units for each tick..
+    bool pending_requirements = false;                                                                                                 // whether there are pending requirements to be solved or not..
+    utils::rational current_time;                                                                                                      // the current time in plan units..
+    std::unordered_set<const riddle::atom_term *> executing;                                                                           // the atoms that are currently executing..
+    std::map<utils::inf_rational, std::pair<std::unordered_set<riddle::atom_term *>, std::unordered_set<riddle::atom_term *>>> pulses; // the pulses of the executor, with the starting and ending atoms..
   };
 } // namespace ratio::executor

include/plexa.hpp

@@ -17,6 +17,8 @@ namespace ratio::executor
   private:
     void adapt() override;
 
+    void delay(riddle::arith_expr tp, const utils::rational &d) override;
+
   private:
     bool pending_requirements = false; // whether there are pending requirements to be solved or not..
   };

include/st/stexecutor.hpp

@@ -41,7 +41,6 @@ namespace ratio::executor
         if (!running)
             return; // if not running, do nothing..
 
-    manage_tick:
         while (!pulses.empty() && pulses.cbegin()->first <= current_time)
         {
             if (!pulses.cbegin()->second.first.empty())
@@ -61,6 +60,13 @@ namespace ratio::executor
         }
     }
 
+    void plexa::dont_start_yet(const std::unordered_map<riddle::atom_term *, utils::rational> &atoms)
+    {
+        for (auto &[atm, d] : atoms)
+            delay(std::dynamic_pointer_cast<riddle::arith_term>(atm->get_core().get_predicate(riddle::impulse_kw).is_assignable_from(atm->get_type()) ? atm->get("at") : atm->get("start")), d);
+    }
+    void plexa::dont_end_yet(const std::unordered_map<riddle::atom_term *, utils::rational> &atoms) { delay(std::dynamic_pointer_cast<riddle::arith_term>(atoms.begin()->first->get("end")), atoms.begin()->second); }
+
     void plexa::build_timelines(const riddle::core &cr)
     {
         LOG_DEBUG("Building timelines");
@@ -77,18 +83,18 @@ namespace ratio::executor
                         auto at = cr.arith_value(static_cast<riddle::arith_term &>(*atm->get("at")));
                         if (at < current_time)
                             continue; // this atom is already in the past..
-                        pulses[at].first.emplace_back(atm.get());
-                        pulses[at].second.emplace_back(atm.get());
+                        pulses[at].first.emplace(atm.get());
+                        pulses[at].second.emplace(atm.get());
                     }
                     else
                     {
                         auto end = cr.arith_value(static_cast<riddle::arith_term &>(*atm->get("end")));
                         if (end < current_time)
                             continue; // this atom is already in the past..
-                        pulses[end].second.emplace_back(atm.get());
+                        pulses[end].second.emplace(atm.get());
                         auto start = cr.arith_value(static_cast<riddle::arith_term &>(*atm->get("start")));
                         if (start >= current_time)
-                            pulses[start].first.emplace_back(atm.get());
+                            pulses[start].first.emplace(atm.get());
                     }
                 }
     }

src/plexa.cpp

@@ -1,4 +1,5 @@
 #include "stexecutor.hpp"
+#include "la_theory.hpp"
 #include "logging.hpp"
 
 namespace ratio::executor
@@ -20,4 +21,6 @@ namespace ratio::executor
     }
 
     void executor::adapt() { solve(); }
+
+    void executor::delay(riddle::arith_expr tp, const utils::rational &d) { get_linear_arithmetic_theory().new_lt(static_cast<riddle::arith_item &>(*tp).get_lin(), utils::lin(arith_value(*tp).get_rational() + d)); }
 } // namespace ratio::executor