Enhance add_constraint method to return success status and implement inconsistency detection in unit tests

Author: riccardodebenedictis

include/linspire.hpp

@@ -161,8 +161,9 @@ namespace linspire
      * the internal state of the solver to account for the new constraint.
      *
      * @param c The constraint to be added.
+     * @return true if the constraint was successfully added; false if it leads to inconsistency.
      */
-    void add_constraint(const constraint &c) noexcept;
+    [[nodiscard]] bool add_constraint(const constraint &c) noexcept;
 
     /**
      * @brief Retracts a previously added constraint from the solver.

src/linspire.cpp

@@ -2,6 +2,7 @@
 #include "logging.hpp"
 #include <algorithm>
 #include <cassert>
+#include <unordered_map>
 
 #ifdef LINSPIRE_ENABLE_LISTENERS
 #define FIRE_ON_VALUE_CHANGED(var)                                       \
@@ -119,12 +120,46 @@ namespace linspire
     }
     bool solver::new_gt(const utils::lin &lhs, const utils::lin &rhs, bool strict, std::optional<std::reference_wrapper<constraint>> reason) noexcept { return new_lt(rhs, lhs, strict, reason); }
 
-    void solver::add_constraint(const constraint &c) noexcept
+    bool solver::add_constraint(const constraint &c) noexcept
     {
-        for (const auto &[x, lb] : c.lbs)
-            vars[x].set_lb(lb, c);
-        for (const auto &[x, ub] : c.ubs)
-            vars[x].set_ub(ub, c);
+        struct staged_bounds
+        {
+            utils::inf_rational lb;
+            utils::inf_rational ub;
+        };
+        std::unordered_map<utils::var, staged_bounds> staged;
+        const auto ensure_entry = [this, &staged](const utils::var x) -> staged_bounds &
+        {
+            const auto it = staged.find(x);
+            if (it != staged.end())
+                return it->second;
+            const auto [inserted_it, _] = staged.emplace(x, staged_bounds{lb(x), ub(x)});
+            return inserted_it->second;
+        };
+
+        for (const auto &[x, lb_val] : c.lbs)
+        {
+            auto &entry = ensure_entry(x);
+            if (lb_val > entry.lb)
+                entry.lb = lb_val;
+            if (entry.lb > entry.ub)
+                return false;
+        }
+
+        for (const auto &[x, ub_val] : c.ubs)
+        {
+            auto &entry = ensure_entry(x);
+            if (ub_val < entry.ub)
+                entry.ub = ub_val;
+            if (entry.lb > entry.ub)
+                return false;
+        }
+
+        for (const auto &[x, lb_val] : c.lbs)
+            vars[x].set_lb(lb_val, c);
+        for (const auto &[x, ub_val] : c.ubs)
+            vars[x].set_ub(ub_val, c);
+        return true;
     }
 
     void solver::retract(const constraint &c) noexcept

tests/test_linspire.cpp

@@ -215,7 +215,8 @@ void test_add_retract_readd_constraint()
     assert(s.ub(x) == utils::rational::positive_infinite);
 
     // Add the same constraint again
-    s.add_constraint(c0);
+    bool added_again = s.add_constraint(c0);
+    assert(added_again);
     cons = s.check();
     assert(cons);
     assert(s.lb(x) == 5);
@@ -270,6 +271,27 @@ void test_expression_bounds_and_match()
     assert(!s.match(expr_x, expr_far));
 }
 
+void test_add_constraint_inconsistency_detection()
+{
+    linspire::solver s;
+    auto x = s.new_var();
+
+    linspire::constraint c_lb;
+    bool lb_ok = s.new_gt({{x, 1}}, 5, false, c_lb);
+    assert(lb_ok);
+    s.retract(c_lb);
+
+    linspire::constraint c_ub;
+    bool ub_ok = s.new_lt({{x, 1}}, 1, false, c_ub);
+    assert(ub_ok);
+    assert(s.check());
+
+    bool add_ok = s.add_constraint(c_lb);
+    assert(!add_ok);
+    assert(s.lb(x) == utils::rational::negative_infinite);
+    assert(s.ub(x) == 1);
+}
+
 int main()
 {
     test_basic_eq_and_lt();
@@ -281,6 +303,7 @@ int main()
     test_constant_inequality_strictness();
     test_slack_variable_reuse_for_duplicate_expression();
     test_expression_bounds_and_match();
+    test_add_constraint_inconsistency_detection();
 
     return 0;
 }