[CP-SAT] add float value to the CpSolver and solution callback classes

lperron · lperron · commit 766be56171c0 · 2025-02-17T14:25:29.000+01:00
diff --git a/ortools/sat/python/cp_model.py b/ortools/sat/python/cp_model.py
@@ -2521,6 +2521,35 @@ def values(self, variables: _IndexOrSeries) -> pd.Series:
             index=_get_index(variables),
         )
 
+    def float_value(self, expression: LinearExprT) -> float:
+        """Returns the value of a linear expression after solve."""
+        return self._checked_response.float_value(expression)
+
+    def float_values(self, expressions: _IndexOrSeries) -> pd.Series:
+        """Returns the float values of the input linear expressions.
+
+        If `expressions` is a `pd.Index`, then the output will be indexed by the
+        variables. If `variables` is a `pd.Series` indexed by the underlying
+        dimensions, then the output will be indexed by the same underlying
+        dimensions.
+
+        Args:
+          expressions (Union[pd.Index, pd.Series]): The set of expressions from
+            which to get the values.
+
+        Returns:
+          pd.Series: The values of all variables in the set.
+
+        Raises:
+          RuntimeError: if solve() has not been called.
+        """
+        if self.__response_wrapper is None:
+            raise RuntimeError("solve() has not been called.")
+        return pd.Series(
+            data=[self.__response_wrapper.float_value(expr) for expr in expressions],
+            index=_get_index(expressions),
+        )
+
     def boolean_value(self, literal: LiteralT) -> bool:
         """Returns the boolean value of a literal after solve."""
         return self._checked_response.boolean_value(literal)
@@ -2796,6 +2825,23 @@ def value(self, expression: LinearExprT) -> int:
             raise RuntimeError("solve() has not been called.")
         return self.Value(expression)
 
+    def float_value(self, expression: LinearExprT) -> float:
+        """Evaluates an linear expression in the current solution.
+
+        Args:
+            expression: a linear expression of the model.
+
+        Returns:
+            An integer value equal to the evaluation of the linear expression
+            against the current solution.
+
+        Raises:
+            RuntimeError: if 'expression' is not a LinearExpr.
+        """
+        if not self.has_response():
+            raise RuntimeError("solve() has not been called.")
+        return self.FloatValue(expression)
+
     def has_response(self) -> bool:
         return self.HasResponse()
 
diff --git a/ortools/sat/python/cp_model_helper.cc b/ortools/sat/python/cp_model_helper.cc
@@ -163,10 +163,19 @@ class ResponseWrapper {
 
   double UserTime() const { return response_.user_time(); }
 
+  double FloatValue(std::shared_ptr<LinearExpr> expr) const {
+    FloatExprVisitor visitor;
+    visitor.AddToProcess(expr, 1);
+    return visitor.Evaluate(response_);
+  }
+
+  double FixedFloatValue(double value) const { return value; }
+
   int64_t Value(std::shared_ptr<LinearExpr> expr) const {
-    IntExprVisitor visitor;
     int64_t value;
-    if (!visitor.Evaluate(expr, response_, &value)) {
+    IntExprVisitor visitor;
+    visitor.AddToProcess(expr, 1);
+    if (!visitor.Evaluate(response_, &value)) {
       ThrowError(PyExc_ValueError,
                  absl::StrCat("Failed to evaluate linear expression: ",
                               expr->DebugString()));
@@ -453,9 +462,10 @@ PYBIND11_MODULE(cp_model_helper, m) {
           "Value",
           [](const SolutionCallback& callback,
              std::shared_ptr<LinearExpr> expr) {
-            IntExprVisitor visitor;
             int64_t value;
-            if (!visitor.Evaluate(expr, callback.Response(), &value)) {
+            IntExprVisitor visitor;
+            visitor.AddToProcess(expr, 1);
+            if (!visitor.Evaluate(callback.Response(), &value)) {
               ThrowError(PyExc_ValueError,
                          absl::StrCat("Failed to evaluate linear expression: ",
                                       expr->DebugString()));
@@ -466,6 +476,21 @@ PYBIND11_MODULE(cp_model_helper, m) {
       .def(
           "Value", [](const SolutionCallback&, int64_t value) { return value; },
           "Returns the value of a linear expression after solve.")
+      .def(
+          "FloatValue",
+          [](const SolutionCallback& callback,
+             std::shared_ptr<LinearExpr> expr) {
+            FloatExprVisitor visitor;
+            visitor.AddToProcess(expr, 1.0);
+            return visitor.Evaluate(callback.Response());
+          },
+          "Returns the value of a floating point linear expression after "
+          "solve.")
+      .def(
+          "FloatValue",
+          [](const SolutionCallback&, double value) { return value; },
+          "Returns the value of a floating point linear expression after "
+          "solve.")
       .def(
           "BooleanValue",
           [](const SolutionCallback& callback, std::shared_ptr<Literal> lit) {
@@ -495,6 +520,8 @@ PYBIND11_MODULE(cp_model_helper, m) {
       .def("sufficient_assumptions_for_infeasibility",
            &ResponseWrapper::SufficientAssumptionsForInfeasibility)
       .def("user_time", &ResponseWrapper::UserTime)
+      .def("float_value", &ResponseWrapper::FloatValue, py::arg("expr"))
+      .def("float_value", &ResponseWrapper::FixedFloatValue, py::arg("value"))
       .def("value", &ResponseWrapper::Value, py::arg("expr"))
       .def("value", &ResponseWrapper::FixedValue, py::arg("value"))
       .def("wall_time", &ResponseWrapper::WallTime);
diff --git a/ortools/sat/python/cp_model_test.py b/ortools/sat/python/cp_model_test.py
@@ -57,6 +57,22 @@ def sum(self) -> int:
         return self.__sum
 
 
+class SolutionFloatValue(cp_model.CpSolverSolutionCallback):
+    """Record the evaluation of a float expression in the solution."""
+
+    def __init__(self, expr: cp_model.LinearExpr) -> None:
+        cp_model.CpSolverSolutionCallback.__init__(self)
+        self.__expr: cp_model.LinearExpr = expr
+        self.__value: float = 0.0
+
+    def on_solution_callback(self) -> None:
+        self.__value = self.float_value(self.__expr)
+
+    @property
+    def value(self) -> float:
+        return self.__value
+
+
 class SolutionObjective(cp_model.CpSolverSolutionCallback):
     """Record the objective value of the solution."""
 
@@ -1515,6 +1531,18 @@ def test_solve_with_solution_callback(self) -> None:
         self.assertEqual(cp_model.OPTIMAL, status)
         self.assertEqual(6, solution_sum.sum)
 
+    def test_solve_with_float_value_in_callback(self) -> None:
+        model = cp_model.CpModel()
+        x = model.new_int_var(0, 5, "x")
+        y = model.new_int_var(0, 5, "y")
+        model.add_linear_constraint(x + y, 6, 6)
+
+        solver = cp_model.CpSolver()
+        solution_float_value = SolutionFloatValue((x + y) * 0.5)
+        status = solver.solve(model, solution_float_value)
+        self.assertEqual(cp_model.OPTIMAL, status)
+        self.assertEqual(3.0, solution_float_value.value)
+
     def test_best_bound_callback(self) -> None:
         model = cp_model.CpModel()
         x0 = model.new_bool_var("x0")
@@ -1545,6 +1573,17 @@ def test_value(self) -> None:
         self.assertEqual(solver.value(y), 10)
         self.assertEqual(solver.value(2), 2)
 
+    def test_float_value(self) -> None:
+        model = cp_model.CpModel()
+        x = model.new_int_var(0, 10, "x")
+        y = model.new_int_var(0, 10, "y")
+        model.add(x + 2 * y == 29)
+        solver = cp_model.CpSolver()
+        status = solver.solve(model)
+        self.assertEqual(cp_model.OPTIMAL, status)
+        self.assertEqual(solver.float_value(x * 1.5 + 0.25), 13.75)
+        self.assertEqual(solver.float_value(2.25), 2.25)
+
     def test_boolean_value(self) -> None:
         model = cp_model.CpModel()
         x = model.new_bool_var("x")
diff --git a/ortools/sat/python/linear_expr.cc b/ortools/sat/python/linear_expr.cc
@@ -130,20 +130,25 @@ void FloatExprVisitor::AddToProcess(std::shared_ptr<LinearExpr> expr,
                                     double coeff) {
   to_process_.push_back(std::make_pair(expr, coeff));
 }
+
 void FloatExprVisitor::AddConstant(double constant) { offset_ += constant; }
+
 void FloatExprVisitor::AddVarCoeff(std::shared_ptr<BaseIntVar> var,
                                    double coeff) {
   canonical_terms_[var] += coeff;
 }
-double FloatExprVisitor::Process(std::shared_ptr<LinearExpr> expr,
-                                 std::vector<std::shared_ptr<BaseIntVar>>* vars,
-                                 std::vector<double>* coeffs) {
-  AddToProcess(expr, 1.0);
+
+void FloatExprVisitor::ProcessAll() {
   while (!to_process_.empty()) {
     const auto [expr, coeff] = to_process_.back();
     to_process_.pop_back();
     expr->VisitAsFloat(*this, coeff);
   }
+}
+
+double FloatExprVisitor::Process(std::vector<std::shared_ptr<BaseIntVar>>* vars,
+                                 std::vector<double>* coeffs) {
+  ProcessAll();
 
   vars->clear();
   coeffs->clear();
@@ -156,9 +161,20 @@ double FloatExprVisitor::Process(std::shared_ptr<LinearExpr> expr,
   return offset_;
 }
 
+double FloatExprVisitor::Evaluate(const CpSolverResponse& solution) {
+  ProcessAll();
+
+  for (const auto& [var, coeff] : canonical_terms_) {
+    if (coeff == 0) continue;
+    offset_ += coeff * solution.solution(var->index());
+  }
+  return offset_;
+}
+
 FlatFloatExpr::FlatFloatExpr(std::shared_ptr<LinearExpr> expr) {
   FloatExprVisitor lin;
-  offset_ = lin.Process(expr, &vars_, &coeffs_);
+  lin.AddToProcess(expr, 1.0);
+  offset_ = lin.Process(&vars_, &coeffs_);
 }
 
 void FlatFloatExpr::VisitAsFloat(FloatExprVisitor& lin, double c) {
@@ -735,10 +751,8 @@ bool IntExprVisitor::Process(std::vector<std::shared_ptr<BaseIntVar>>* vars,
   return true;
 }
 
-bool IntExprVisitor::Evaluate(std::shared_ptr<LinearExpr> expr,
-                              const CpSolverResponse& solution,
+bool IntExprVisitor::Evaluate(const CpSolverResponse& solution,
                               int64_t* value) {
-  AddToProcess(expr, 1);
   if (!ProcessAll()) return false;
 
   *value = offset_;
diff --git a/ortools/sat/python/linear_expr.h b/ortools/sat/python/linear_expr.h
@@ -160,9 +160,10 @@ class FloatExprVisitor {
   void AddToProcess(std::shared_ptr<LinearExpr> expr, double coeff);
   void AddConstant(double constant);
   void AddVarCoeff(std::shared_ptr<BaseIntVar> var, double coeff);
-  double Process(std::shared_ptr<LinearExpr> expr,
-                 std::vector<std::shared_ptr<BaseIntVar>>* vars,
+  void ProcessAll();
+  double Process(std::vector<std::shared_ptr<BaseIntVar>>* vars,
                  std::vector<double>* coeffs);
+  double Evaluate(const CpSolverResponse& solution);
 
  private:
   std::vector<std::pair<std::shared_ptr<LinearExpr>, double>> to_process_;
@@ -212,8 +213,7 @@ class IntExprVisitor {
   bool ProcessAll();
   bool Process(std::vector<std::shared_ptr<BaseIntVar>>* vars,
                std::vector<int64_t>* coeffs, int64_t* offset);
-  bool Evaluate(std::shared_ptr<LinearExpr> expr,
-                const CpSolverResponse& solution, int64_t* value);
+  bool Evaluate(const CpSolverResponse& solution, int64_t* value);
 
  private:
   std::vector<std::pair<std::shared_ptr<LinearExpr>, int64_t>> to_process_;
