Refactor constraint pointer types: update shared_ptr usage to const in var class methods for improved type safety

Author: riccardodebenedictis

include/linspire.hpp

@@ -182,7 +182,7 @@ namespace linspire
      *
      * @return A constant reference to a vector of shared pointers to constraint objects representing the last conflict explanation.
      */
-    [[nodiscard]] const std::vector<std::shared_ptr<constraint>> &get_conflict() const noexcept { return cnfl; }
+    [[nodiscard]] const std::vector<std::shared_ptr<const constraint>> &get_conflict() const noexcept { return cnfl; }
 
     friend std::string to_string(const solver &s) noexcept;
     friend json::json to_json(const solver &s) noexcept;
@@ -201,11 +201,11 @@ namespace linspire
 
     void new_row(const utils::var x, utils::lin &&l) noexcept;
 
-    std::vector<var> vars;                             // index is the variable id
-    std::unordered_map<std::string, utils::var> exprs; // the expressions (string to numeric variable) for which already exist slack variables..
-    std::map<utils::var, utils::lin> tableau;          // variable -> expression
-    std::vector<std::set<utils::var>> t_watches;       // for each variable `v`, a set of tableau rows watching `v`..
-    std::vector<std::shared_ptr<constraint>> cnfl;     // the last conflict explanation..
+    std::vector<var> vars;                               // index is the variable id
+    std::unordered_map<std::string, utils::var> exprs;   // the expressions (string to numeric variable) for which already exist slack variables..
+    std::map<utils::var, utils::lin> tableau;            // basic variable -> expression
+    std::vector<std::set<utils::var>> t_watches;         // for each variable `v`, a set of tableau rows watching `v`..
+    std::vector<std::shared_ptr<const constraint>> cnfl; // the last conflict explanation..
   };
 
   class constraint

include/var.hpp

@@ -25,15 +25,15 @@ namespace linspire
     friend json::json to_json(const var &x) noexcept;
 
   private:
-    void set_lb(const utils::inf_rational &v, std::shared_ptr<constraint> reason = nullptr) noexcept;
-    void unset_lb(const utils::inf_rational &v, std::shared_ptr<constraint> reason) noexcept;
-    void set_ub(const utils::inf_rational &v, std::shared_ptr<constraint> reason = nullptr) noexcept;
-    void unset_ub(const utils::inf_rational &v, std::shared_ptr<constraint> reason) noexcept;
+    void set_lb(const utils::inf_rational &v, std::shared_ptr<const constraint> reason = nullptr) noexcept;
+    void unset_lb(const utils::inf_rational &v, std::shared_ptr<const constraint> reason) noexcept;
+    void set_ub(const utils::inf_rational &v, std::shared_ptr<const constraint> reason = nullptr) noexcept;
+    void unset_ub(const utils::inf_rational &v, std::shared_ptr<const constraint> reason) noexcept;
 
   private:
-    const utils::var id;                                                           // the id of this variable in the solver..
-    std::map<utils::inf_rational, std::set<std::shared_ptr<constraint>>> lbs, ubs; // the lower and upper bounds with their reasons..
-    utils::inf_rational val;                                                       // the current value of this variable..
+    const utils::var id;                                                                 // the id of this variable in the solver..
+    std::map<utils::inf_rational, std::set<std::shared_ptr<const constraint>>> lbs, ubs; // the lower and upper bounds with their reasons..
+    utils::inf_rational val;                                                             // the current value of this variable..
   };
 
   [[nodiscard]] std::string to_string(const var &x) noexcept;

src/var.cpp

@@ -9,24 +9,24 @@ namespace linspire
     utils::inf_rational var::get_lb() const noexcept { return lbs.empty() ? utils::rational::negative_infinite : lbs.rbegin()->first; }
     utils::inf_rational var::get_ub() const noexcept { return ubs.empty() ? utils::rational::positive_infinite : ubs.begin()->first; }
 
-    void var::set_lb(const utils::inf_rational &v, std::shared_ptr<constraint> reason) noexcept
+    void var::set_lb(const utils::inf_rational &v, std::shared_ptr<const constraint> reason) noexcept
     {
         assert(v <= get_ub()); // we cannot set a lower bound greater than the current upper bound..
         if (reason)
         { // we add a new lower bound `v` with the given reason..
             if (auto it = lbs.find(v); it != lbs.end())
                 it->second.insert(reason); // we add the reason to the existing lower bound `v`..
             else
-                lbs.emplace(v, std::set<std::shared_ptr<constraint>>{reason}); // we create a new lower bound `v`..
+                lbs.emplace(v, std::set<std::shared_ptr<const constraint>>{reason}); // we create a new lower bound `v`..
         }
         else
         { // we remove all the lower bounds that are less than `v`..
             auto it = lbs.upper_bound(v);
             lbs.erase(lbs.begin(), it);
-            lbs.emplace(v, std::set<std::shared_ptr<constraint>>());
+            lbs.emplace(v, std::set<std::shared_ptr<const constraint>>());
         }
     }
-    void var::unset_lb(const utils::inf_rational &v, std::shared_ptr<constraint> reason) noexcept
+    void var::unset_lb(const utils::inf_rational &v, std::shared_ptr<const constraint> reason) noexcept
     {
         assert(lbs.find(v) != lbs.end());
         assert(reason);
@@ -36,24 +36,24 @@ namespace linspire
             lbs.erase(it);
     }
 
-    void var::set_ub(const utils::inf_rational &v, std::shared_ptr<constraint> reason) noexcept
+    void var::set_ub(const utils::inf_rational &v, std::shared_ptr<const constraint> reason) noexcept
     {
         assert(v >= get_lb()); // we cannot set an upper bound less than the current lower bound..
         if (reason)
         { // we add a new upper bound `v` with the given reason..
             if (auto it = ubs.find(v); it != ubs.end())
                 it->second.insert(reason); // we add the reason to the existing upper bound `v`..
             else
-                ubs.emplace(v, std::set<std::shared_ptr<constraint>>{reason}); // we create a new upper bound `v`..
+                ubs.emplace(v, std::set<std::shared_ptr<const constraint>>{reason}); // we create a new upper bound `v`..
         }
         else
         { // we remove all the upper bounds that are greater than `v`..
             auto it = ubs.lower_bound(v);
             ubs.erase(it, ubs.end());
-            ubs.emplace(v, std::set<std::shared_ptr<constraint>>());
+            ubs.emplace(v, std::set<std::shared_ptr<const constraint>>());
         }
     }
-    void var::unset_ub(const utils::inf_rational &v, std::shared_ptr<constraint> reason) noexcept
+    void var::unset_ub(const utils::inf_rational &v, std::shared_ptr<const constraint> reason) noexcept
     {
         assert(ubs.find(v) != ubs.end());
         assert(reason);