Make Highs support two sided linear constraint

Author: metab0t

include/pyoptinterface/highs_model.hpp

@@ -112,6 +112,7 @@ struct POIHighsSolution
 };
 
 class POIHighsModel : public OnesideLinearConstraintMixin<POIHighsModel>,
+                      public TwosideLinearConstraintMixin<POIHighsModel>,
                       public LinearObjectiveMixin<POIHighsModel>,
                       public PPrintMixin<POIHighsModel>,
                       public GetValueMixin<POIHighsModel>
@@ -136,6 +137,9 @@ class POIHighsModel : public OnesideLinearConstraintMixin<POIHighsModel>,
 	ConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,
 	                                      ConstraintSense sense, CoeffT rhs,
 	                                      const char *name = nullptr);
+	ConstraintIndex add_linear_constraint(const ScalarAffineFunction &function,
+	                                      const std::tuple<double, double> &interval,
+	                                      const char *name = nullptr);
 	ConstraintIndex add_quadratic_constraint(const ScalarQuadraticFunction &function,
 	                                         ConstraintSense sense, CoeffT rhs,
 	                                         const char *name = nullptr);

lib/highs_model.cpp

@@ -257,6 +257,30 @@ void POIHighsModel::set_variable_bounds(const VariableIndex &variable, double lb
 ConstraintIndex POIHighsModel::add_linear_constraint(const ScalarAffineFunction &function,
                                                      ConstraintSense sense, CoeffT rhs,
                                                      const char *name)
+{
+	double lb = -kHighsInf;
+	double ub = kHighsInf;
+	switch (sense)
+	{
+	case ConstraintSense::LessEqual:
+		ub = rhs;
+		break;
+	case ConstraintSense::GreaterEqual:
+		lb = rhs;
+		break;
+	case ConstraintSense::Equal:
+		lb = rhs;
+		ub = rhs;
+		break;
+	}
+
+	auto con = add_linear_constraint(function, std::make_tuple(lb, ub), name);
+	return con;
+}
+
+ConstraintIndex POIHighsModel::add_linear_constraint(const ScalarAffineFunction &function,
+                                                     const std::tuple<double, double> &interval,
+                                                     const char *name)
 {
 	IndexT index = m_linear_constraint_index.add_index();
 	ConstraintIndex constraint(ConstraintType::Linear, index);
@@ -268,21 +292,12 @@ ConstraintIndex POIHighsModel::add_linear_constraint(const ScalarAffineFunction
 	HighsInt *cind = ptr_form.index;
 	double *cval = ptr_form.value;
 
-	double lb = -kHighsInf;
-	double ub = kHighsInf;
-	double g_rhs = rhs - function.constant.value_or(0.0);
-	switch (sense)
+	double lb = std::get<0>(interval);
+	double ub = std::get<1>(interval);
+	if (function.constant.has_value())
 	{
-	case ConstraintSense::LessEqual:
-		ub = g_rhs;
-		break;
-	case ConstraintSense::GreaterEqual:
-		lb = g_rhs;
-		break;
-	case ConstraintSense::Equal:
-		lb = g_rhs;
-		ub = g_rhs;
-		break;
+		lb -= function.constant.value();
+		ub -= function.constant.value();
 	}
 
 	auto error = highs::Highs_addRow(m_model.get(), lb, ub, numnz, cind, cval);

lib/highs_model_ext.cpp

@@ -1,5 +1,6 @@
 #include <nanobind/nanobind.h>
 #include <nanobind/stl/string.h>
+#include <nanobind/stl/tuple.h>
 #include <nanobind/stl/vector.h>
 
 #include "pyoptinterface/highs_model.hpp"
@@ -78,12 +79,23 @@ NB_MODULE(highs_model_ext, m)
 	         nb::overload_cast<const ExprBuilder &, int>(&HighsModel::pprint_expression),
 	         nb::arg("expr"), nb::arg("precision") = 4)
 
-	    .def("_add_linear_constraint", &HighsModel::add_linear_constraint, nb::arg("expr"),
-	         nb::arg("sense"), nb::arg("rhs"), nb::arg("name") = "")
-	    .def("_add_linear_constraint", &HighsModel::add_linear_constraint_from_var,
+	    .def("_add_linear_constraint",
+	         nb::overload_cast<const ScalarAffineFunction &, ConstraintSense, CoeffT, const char *>(
+	             &HighsModel::add_linear_constraint),
 	         nb::arg("expr"), nb::arg("sense"), nb::arg("rhs"), nb::arg("name") = "")
+	    .def("_add_linear_constraint",
+	         nb::overload_cast<const ScalarAffineFunction &, const std::tuple<double, double> &,
+	                           const char *>(&HighsModel::add_linear_constraint),
+	         nb::arg("expr"), nb::arg("interval"), nb::arg("name") = "")
+	    .def("_add_linear_constraint", &HighsModel::add_linear_constraint_from_var, nb::arg("expr"),
+	         nb::arg("sense"), nb::arg("rhs"), nb::arg("name") = "")
+	    .def("_add_linear_constraint", &HighsModel::add_linear_interval_constraint_from_var,
+	         nb::arg("expr"), nb::arg("interval"), nb::arg("name") = "")
 	    .def("_add_linear_constraint", &HighsModel::add_linear_constraint_from_expr,
 	         nb::arg("expr"), nb::arg("sense"), nb::arg("rhs"), nb::arg("name") = "")
+	    .def("_add_linear_constraint", &HighsModel::add_linear_interval_constraint_from_expr,
+	         nb::arg("expr"), nb::arg("interval"), nb::arg("name") = "")
+
 	    .def("delete_constraint", &HighsModel::delete_constraint)
 	    .def("is_constraint_active", &HighsModel::is_constraint_active)
 

lib/mosek_model.cpp

@@ -1484,7 +1484,8 @@ void MOSEKEnv::close()
 {
 	if (m_env != nullptr)
 	{
-		mosek::MSK_deleteenv(&m_env);
+		auto error = mosek::MSK_deleteenv(&m_env);
+		check_error(error);
 	}
 	m_env = nullptr;
 }

tests/test_in_constraint.py

@@ -1,10 +1,14 @@
 import pyoptinterface as poi
+from pyoptinterface import nl, gurobi
 
 import pytest
 
 
-def test_in_constraint_sense(nlp_model_ctor):
-    model = nlp_model_ctor()
+def test_linear_in_constraint(model_interface):
+    model = model_interface
+
+    if isinstance(model, gurobi.Model):
+        pytest.skip("Gurobi does not support range linear constraints")
 
     x = model.add_variable(lb=0.0)
     y = model.add_variable(lb=0.0)
@@ -22,3 +26,19 @@ def test_in_constraint_sense(nlp_model_ctor):
 
     expr_value = model.get_value(expr)
     assert expr_value == pytest.approx(1.0, rel=1e-6)
+
+
+def test_nl_in_constraint(nlp_model_ctor):
+    model = nlp_model_ctor()
+
+    x = model.add_variable(lb=0.0)
+    y = model.add_variable(lb=0.0)
+
+    with nl.graph():
+        expr = nl.exp(x) + nl.exp(y)
+        model.add_nl_constraint(expr, (5.0, 10.0))
+        model.add_nl_objective(expr)
+
+    model.optimize()
+    objective_value = model.get_model_attribute(poi.ModelAttribute.ObjectiveValue)
+    assert objective_value == pytest.approx(5.0, abs=1e-6)