or-tools 0.4.1 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7ce5b035a9a0f52391ef97cd12d32ec7632101940fde4e2f19de4887900a4dc1
-  data.tar.gz: c63b37906fb5337cd805c627266422ccfc698d3759456327e2414f5e31e4ab52
+  metadata.gz: 4e179505f9df7d80af6a316ca719594fa2a99839c8c26b0f33ee1551b4e7b2d3
+  data.tar.gz: b05dc3c553d11112e55855bb91b0382a3a648a14848e5c9d6e3805bf52e009fb
 SHA512:
-  metadata.gz: 5eda4c29a50790d7c569e67b9538ac2c13a6cd20af1580cd679a68d386244b5cd1bbafa311c52fe9cad519652bbfb6666aed09e6a5ae1f7c71cc666491644d4f
-  data.tar.gz: 5241d2788f6883ca0349967e4f953382cd03564fe4856e853888518427a2ed5ec8a8cf948aac34a02b39f413c787eeb98ff22284f59359f7cf9a9aa73b449188
+  metadata.gz: fa77b818baf408c3cf30b56065f0b9b7f877358e1f0d39718a3ebc1f49fc4dae78da9678875c340895427f189074939e220ffa320207bea76bd0d7921f0675d7
+  data.tar.gz: 7c174df348ad0835c93a56ecb51a6f9763aaba43f0d3fc3eaf0b8b745922a204d86ee6fae6ba3fba632b284179251decbbfce17b2a1dd1e608d91b96cf3ff9ec

data/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 0.5.2 (2021-07-07)
+
+- Added `export_model_as_lp_format` and `export_model_as_mps_format` to `Solver`
+
+## 0.5.1 (2021-05-23)
+
+- Updated to Rice 4
+
+## 0.5.0 (2021-04-30)
+
+- Updated OR-Tools to 9.0
+- Added binary installation for CentOS 7
+- Added `sufficient_assumptions_for_infeasibility` to `CpSolver`
+
+## 0.4.3 (2021-03-26)
+
+- Added `add_assumption`, `add_assumptions`, and `clear_assumptions` to `CpModel`
+- Added `add_hint` and `clear_hints` to `CpModel`
+- Added `only_enforce_if` to `SatConstraint`
+- Fixed installation for Debian
+
+## 0.4.2 (2021-03-03)
+
+- Updated OR-Tools to 8.2
+
 ## 0.4.1 (2021-02-23)
 
 - Added solution printers

data/ext/or-tools/assignment.cpp

@@ -1,12 +1,9 @@
 #include <ortools/graph/assignment.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using operations_research::SimpleLinearSumAssignment;
 
-using Rice::Array;
 using Rice::Symbol;
 
 void init_assignment(Rice::Module& m) {
@@ -23,7 +20,7 @@ void init_assignment(Rice::Module& m) {
     .define_method("assignment_cost", &SimpleLinearSumAssignment::AssignmentCost)
     .define_method(
       "solve",
-      *[](SimpleLinearSumAssignment& self) {
+      [](SimpleLinearSumAssignment& self) {
         auto status = self.Solve();
 
         if (status == SimpleLinearSumAssignment::Status::OPTIMAL) {

data/ext/or-tools/bin_packing.cpp

@@ -1,8 +1,6 @@
 #include <ortools/algorithms/knapsack_solver.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using operations_research::KnapsackSolver;
 
@@ -10,16 +8,31 @@ using Rice::Array;
 using Rice::Object;
 using Rice::Symbol;
 
-template<>
-inline
-KnapsackSolver::SolverType from_ruby<KnapsackSolver::SolverType>(Object x)
+namespace Rice::detail
 {
-  std::string s = Symbol(x).str();
-  if (s == "branch_and_bound") {
-    return KnapsackSolver::KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER;
-  } else {
-    throw std::runtime_error("Unknown solver type: " + s);
-  }
+  template<>
+  struct Type<KnapsackSolver::SolverType>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  class From_Ruby<KnapsackSolver::SolverType>
+  {
+  public:
+    KnapsackSolver::SolverType convert(VALUE x)
+    {
+      auto s = Symbol(x).str();
+      if (s == "branch_and_bound") {
+        return KnapsackSolver::KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER;
+      } else {
+        throw std::runtime_error("Unknown solver type: " + s);
+      }
+    }
+  };
 }
 
 void init_bin_packing(Rice::Module& m) {
@@ -29,27 +42,7 @@ void init_bin_packing(Rice::Module& m) {
     .define_method("best_solution_contains?", &KnapsackSolver::BestSolutionContains)
     .define_method(
       "init",
-      *[](KnapsackSolver& self, Array rb_values, Array rb_weights, Array rb_capacities) {
-        std::vector<int64> values;
-        for (std::size_t i = 0; i < rb_values.size(); ++i) {
-          values.push_back(from_ruby<int64>(rb_values[i]));
-        }
-
-        std::vector<std::vector<int64>> weights;
-        for (std::size_t i = 0; i < rb_weights.size(); ++i) {
-          Array rb_w = Array(rb_weights[i]);
-          std::vector<int64> w;
-          for (std::size_t j = 0; j < rb_w.size(); ++j) {
-            w.push_back(from_ruby<int64>(rb_w[j]));
-          }
-          weights.push_back(w);
-        }
-
-        std::vector<int64> capacities;
-        for (std::size_t i = 0; i < rb_capacities.size(); ++i) {
-          capacities.push_back(from_ruby<int64>(rb_capacities[i]));
-        }
-
+       [](KnapsackSolver& self, std::vector<int64_t> values, std::vector<std::vector<int64_t>> weights, std::vector<int64_t> capacities) {
         self.Init(values, weights, capacities);
       });
 }

data/ext/or-tools/constraint.cpp

@@ -1,9 +1,7 @@
 #include <google/protobuf/text_format.h>
 #include <ortools/sat/cp_model.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using operations_research::sat::BoolVar;
 using operations_research::sat::Constraint;
@@ -20,153 +18,113 @@ using operations_research::sat::SolutionBooleanValue;
 using operations_research::sat::SolutionIntegerValue;
 
 using Rice::Array;
+using Rice::Class;
 using Rice::Object;
 using Rice::String;
 using Rice::Symbol;
 
-template<>
-inline
-LinearExpr from_ruby<LinearExpr>(Object x)
-{
-  LinearExpr expr;
+Class rb_cBoolVar;
+Class rb_cSatIntVar;
 
-  if (x.respond_to("to_i")) {
-    expr = from_ruby<int64>(x.call("to_i"));
-  } else if (x.respond_to("vars")) {
-    Array vars = x.call("vars");
-    for(auto const& var: vars) {
-      auto cvar = (Array) var;
-      // TODO clean up
-      Object o = cvar[0];
-      std::string type = ((String) o.call("class").call("name")).str();
-      if (type == "ORTools::BoolVar") {
-        expr.AddTerm(from_ruby<BoolVar>(cvar[0]), from_ruby<int64>(cvar[1]));
-      } else if (type == "Integer") {
-        expr.AddConstant(from_ruby<int64>(cvar[0]) * from_ruby<int64>(cvar[1]));
-      } else {
-        expr.AddTerm(from_ruby<IntVar>(cvar[0]), from_ruby<int64>(cvar[1]));
-      }
-    }
-  } else {
-    std::string type = ((String) x.call("class").call("name")).str();
-    if (type == "ORTools::BoolVar") {
-      expr = from_ruby<BoolVar>(x);
-    } else {
-      expr = from_ruby<IntVar>(x);
+namespace Rice::detail
+{
+  template<>
+  struct Type<LinearExpr>
+  {
+    static bool verify()
+    {
+      return true;
     }
-  }
-
-  return expr;
-}
+  };
 
-// need a wrapper class since absl::Span doesn't own
-class IntVarSpan {
-  std::vector<IntVar> vec;
+  template<>
+  class From_Ruby<LinearExpr>
+  {
   public:
-    IntVarSpan(Object x) {
-      Array a = Array(x);
-      vec.reserve(a.size());
-      for (std::size_t i = 0; i < a.size(); ++i) {
-        vec.push_back(from_ruby<IntVar>(a[i]));
-      }
-    }
-    operator absl::Span<const IntVar>() {
-      return absl::Span<const IntVar>(vec);
-    }
-};
+    LinearExpr convert(VALUE v)
+    {
+      Object x(v);
+      LinearExpr expr;
 
-template<>
-inline
-IntVarSpan from_ruby<IntVarSpan>(Object x)
-{
-  return IntVarSpan(x);
-}
+      if (x.respond_to("to_i")) {
+        expr = From_Ruby<int64_t>().convert(x.call("to_i").value());
+      } else if (x.respond_to("vars")) {
+        Array vars = x.call("vars");
+        for (const auto& v : vars) {
+          // TODO clean up
+          auto cvar = (Array) v;
+          Object var = cvar[0];
+          auto coeff = From_Ruby<int64_t>().convert(cvar[1].value());
 
-// need a wrapper class since absl::Span doesn't own
-class IntervalVarSpan {
-  std::vector<IntervalVar> vec;
-  public:
-    IntervalVarSpan(Object x) {
-      Array a = Array(x);
-      vec.reserve(a.size());
-      for (std::size_t i = 0; i < a.size(); ++i) {
-        vec.push_back(from_ruby<IntervalVar>(a[i]));
+          if (var.is_a(rb_cBoolVar)) {
+            expr.AddTerm(From_Ruby<BoolVar>().convert(var.value()), coeff);
+          } else if (var.is_a(rb_cInteger)) {
+            expr.AddConstant(From_Ruby<int64_t>().convert(var.value()) * coeff);
+          } else {
+            expr.AddTerm(From_Ruby<IntVar>().convert(var.value()), coeff);
+          }
+        }
+      } else {
+        if (x.is_a(rb_cBoolVar)) {
+          expr = From_Ruby<BoolVar>().convert(x.value());
+        } else {
+          expr = From_Ruby<IntVar>().convert(x.value());
+        }
       }
-    }
-    operator absl::Span<const IntervalVar>() {
-      return absl::Span<const IntervalVar>(vec);
-    }
-};
 
-template<>
-inline
-IntervalVarSpan from_ruby<IntervalVarSpan>(Object x)
-{
-  return IntervalVarSpan(x);
-}
-
-// need a wrapper class since absl::Span doesn't own
-class LinearExprSpan {
-  std::vector<LinearExpr> vec;
-  public:
-    LinearExprSpan(Object x) {
-      Array a = Array(x);
-      vec.reserve(a.size());
-      for (std::size_t i = 0; i < a.size(); ++i) {
-        vec.push_back(from_ruby<LinearExpr>(a[i]));
-      }
-    }
-    operator absl::Span<const LinearExpr>() {
-      return absl::Span<const LinearExpr>(vec);
+      return expr;
     }
-};
+  };
 
-template<>
-inline
-LinearExprSpan from_ruby<LinearExprSpan>(Object x)
-{
-  return LinearExprSpan(x);
-}
-
-// need a wrapper class since absl::Span doesn't own
-class BoolVarSpan {
-  std::vector<BoolVar> vec;
+  template<>
+  class From_Ruby<std::vector<BoolVar>>
+  {
   public:
-    BoolVarSpan(Object x) {
-      Array a = Array(x);
+    std::vector<BoolVar> convert(VALUE v)
+    {
+      auto a = Array(v);
+      std::vector<BoolVar> vec;
       vec.reserve(a.size());
-      for (std::size_t i = 0; i < a.size(); ++i) {
-        vec.push_back(from_ruby<BoolVar>(a[i]));
+      for (const Object v : a) {
+        if (v.is_a(rb_cSatIntVar)) {
+          vec.push_back(From_Ruby<IntVar>().convert(v.value()).ToBoolVar());
+        } else {
+          vec.push_back(From_Ruby<BoolVar>().convert(v.value()));
+        }
       }
+      return vec;
     }
-    operator absl::Span<const BoolVar>() {
-      return absl::Span<const BoolVar>(vec);
-    }
-};
-
-template<>
-inline
-BoolVarSpan from_ruby<BoolVarSpan>(Object x)
-{
-  return BoolVarSpan(x);
+  };
 }
 
 void init_constraint(Rice::Module& m) {
-  Rice::define_class_under<IntVar>(m, "SatIntVar")
+  rb_cSatIntVar = Rice::define_class_under<IntVar>(m, "SatIntVar")
     .define_method("name", &IntVar::Name);
 
   Rice::define_class_under<IntervalVar>(m, "SatIntervalVar")
     .define_method("name", &IntervalVar::Name);
 
-  Rice::define_class_under<Constraint>(m, "SatConstraint");
+  Rice::define_class_under<Constraint>(m, "SatConstraint")
+    .define_method(
+      "only_enforce_if",
+      [](Constraint& self, Object literal) {
+        if (literal.is_a(rb_cSatIntVar)) {
+          return self.OnlyEnforceIf(Rice::detail::From_Ruby<IntVar>().convert(literal).ToBoolVar());
+        } else if (literal.is_a(rb_cArray)) {
+          // TODO support IntVarSpan
+          return self.OnlyEnforceIf(Rice::detail::From_Ruby<std::vector<BoolVar>>().convert(literal));
+        } else {
+          return self.OnlyEnforceIf(Rice::detail::From_Ruby<BoolVar>().convert(literal));
+        }
+      });
 
-  Rice::define_class_under<BoolVar>(m, "BoolVar")
+  rb_cBoolVar = Rice::define_class_under<BoolVar>(m, "BoolVar")
     .define_method("name", &BoolVar::Name)
     .define_method("index", &BoolVar::index)
     .define_method("not", &BoolVar::Not)
     .define_method(
       "inspect",
-      *[](BoolVar& self) {
+      [](BoolVar& self) {
         String name(self.Name());
         return "#<ORTools::BoolVar @name=" + name.inspect().str() + ">";
       });
@@ -174,7 +132,7 @@ void init_constraint(Rice::Module& m) {
   Rice::define_class_under<SatParameters>(m, "SatParameters")
     .define_constructor(Rice::Constructor<SatParameters>())
     .define_method("max_time_in_seconds=",
-    *[](SatParameters& self, double value) {
+    [](SatParameters& self, double value) {
       self.set_max_time_in_seconds(value);
     });
 
@@ -182,178 +140,245 @@ void init_constraint(Rice::Module& m) {
     .define_constructor(Rice::Constructor<CpModelBuilder>())
     .define_method(
       "new_int_var",
-      *[](CpModelBuilder& self, int64 start, int64 end, std::string name) {
+      [](CpModelBuilder& self, int64_t start, int64_t end, const std::string& name) {
         const operations_research::Domain domain(start, end);
         return self.NewIntVar(domain).WithName(name);
       })
     .define_method(
       "new_bool_var",
-      *[](CpModelBuilder& self, std::string name) {
+      [](CpModelBuilder& self, const std::string& name) {
         return self.NewBoolVar().WithName(name);
       })
     .define_method(
       "new_constant",
-      *[](CpModelBuilder& self, int64 value) {
+      [](CpModelBuilder& self, int64_t value) {
         return self.NewConstant(value);
       })
     .define_method(
       "true_var",
-      *[](CpModelBuilder& self) {
+      [](CpModelBuilder& self) {
         return self.TrueVar();
       })
     .define_method(
       "false_var",
-      *[](CpModelBuilder& self) {
+      [](CpModelBuilder& self) {
         return self.FalseVar();
       })
     .define_method(
       "new_interval_var",
-      *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, std::string name) {
+      [](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, const std::string& name) {
         return self.NewIntervalVar(start, size, end).WithName(name);
       })
     .define_method(
       "new_optional_interval_var",
-      *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, BoolVar presence, std::string name) {
+      [](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, BoolVar presence, const std::string& name) {
         return self.NewOptionalIntervalVar(start, size, end, presence).WithName(name);
       })
     .define_method(
       "add_bool_or",
-      *[](CpModelBuilder& self, BoolVarSpan literals) {
-        self.AddBoolOr(literals);
+      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+        return self.AddBoolOr(literals);
       })
     .define_method(
       "add_bool_and",
-      *[](CpModelBuilder& self, BoolVarSpan literals) {
-        self.AddBoolAnd(literals);
+      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+        return self.AddBoolAnd(literals);
       })
     .define_method(
       "add_bool_xor",
-      *[](CpModelBuilder& self, BoolVarSpan literals) {
-        self.AddBoolXor(literals);
+      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+        return self.AddBoolXor(literals);
       })
     .define_method(
       "add_implication",
-      *[](CpModelBuilder& self, BoolVar a, BoolVar b) {
-        self.AddImplication(a, b);
+      [](CpModelBuilder& self, BoolVar a, BoolVar b) {
+        return self.AddImplication(a, b);
       })
     .define_method(
       "add_equality",
-      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddEquality(x, y);
+      [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        return self.AddEquality(x, y);
       })
     .define_method(
       "add_greater_or_equal",
-      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddGreaterOrEqual(x, y);
+      [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        return self.AddGreaterOrEqual(x, y);
       })
     .define_method(
       "add_greater_than",
-      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddGreaterThan(x, y);
+      [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        return self.AddGreaterThan(x, y);
       })
     .define_method(
       "add_less_or_equal",
-      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddLessOrEqual(x, y);
+      [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        return self.AddLessOrEqual(x, y);
       })
     .define_method(
       "add_less_than",
-      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddLessThan(x, y);
+      [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        return self.AddLessThan(x, y);
       })
     // TODO add domain
     // .define_method(
     //   "add_linear_constraint",
-    //   *[](CpModelBuilder& self, LinearExpr expr, Domain domain) {
-    //     self.AddLinearConstraint(expr, domain);
+    //   [](CpModelBuilder& self, LinearExpr expr, Domain domain) {
+    //     return self.AddLinearConstraint(expr, domain);
     //   })
     .define_method(
       "add_not_equal",
-      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddNotEqual(x, y);
+      [](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        return self.AddNotEqual(x, y);
       })
     .define_method(
       "add_all_different",
-      *[](CpModelBuilder& self, IntVarSpan vars) {
-        self.AddAllDifferent(vars);
+      [](CpModelBuilder& self, std::vector<IntVar> vars) {
+        return self.AddAllDifferent(vars);
       })
     .define_method(
       "add_inverse_constraint",
-      *[](CpModelBuilder& self, IntVarSpan variables, IntVarSpan inverse_variables) {
-        self.AddInverseConstraint(variables, inverse_variables);
+      [](CpModelBuilder& self, std::vector<IntVar> variables, std::vector<IntVar> inverse_variables) {
+        return self.AddInverseConstraint(variables, inverse_variables);
       })
     .define_method(
       "add_min_equality",
-      *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
-        self.AddMinEquality(target, vars);
+      [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
+        return self.AddMinEquality(target, vars);
       })
     .define_method(
       "add_lin_min_equality",
-      *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
-        self.AddLinMinEquality(target, exprs);
+      [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> exprs) {
+        return self.AddLinMinEquality(target, exprs);
       })
     .define_method(
       "add_max_equality",
-      *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
-        self.AddMaxEquality(target, vars);
+      [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
+        return self.AddMaxEquality(target, vars);
       })
     .define_method(
       "add_lin_max_equality",
-      *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
-        self.AddLinMaxEquality(target, exprs);
+      [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> exprs) {
+        return self.AddLinMaxEquality(target, exprs);
       })
     .define_method(
       "add_division_equality",
-      *[](CpModelBuilder& self, IntVar target, IntVar numerator, IntVar denominator) {
-        self.AddDivisionEquality(target, numerator, denominator);
+      [](CpModelBuilder& self, IntVar target, IntVar numerator, IntVar denominator) {
+        return self.AddDivisionEquality(target, numerator, denominator);
       })
     .define_method(
       "add_abs_equality",
-      *[](CpModelBuilder& self, IntVar target, IntVar var) {
-        self.AddAbsEquality(target, var);
+      [](CpModelBuilder& self, IntVar target, IntVar var) {
+        return self.AddAbsEquality(target, var);
       })
     .define_method(
       "add_modulo_equality",
-      *[](CpModelBuilder& self, IntVar target, IntVar var, IntVar mod) {
-        self.AddModuloEquality(target, var, mod);
+      [](CpModelBuilder& self, IntVar target, IntVar var, IntVar mod) {
+        return self.AddModuloEquality(target, var, mod);
       })
     .define_method(
       "add_product_equality",
-      *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
-        self.AddProductEquality(target, vars);
+      [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
+        return self.AddProductEquality(target, vars);
       })
     .define_method(
       "add_no_overlap",
-      *[](CpModelBuilder& self, IntervalVarSpan vars) {
-        self.AddNoOverlap(vars);
+      [](CpModelBuilder& self, std::vector<IntervalVar> vars) {
+        return self.AddNoOverlap(vars);
       })
     .define_method(
       "maximize",
-      *[](CpModelBuilder& self, LinearExpr expr) {
+      [](CpModelBuilder& self, LinearExpr expr) {
         self.Maximize(expr);
       })
     .define_method(
       "minimize",
-      *[](CpModelBuilder& self, LinearExpr expr) {
+      [](CpModelBuilder& self, LinearExpr expr) {
         self.Minimize(expr);
       })
     .define_method(
       "scale_objective_by",
-      *[](CpModelBuilder& self, double scaling) {
+      [](CpModelBuilder& self, double scaling) {
         self.ScaleObjectiveBy(scaling);
       })
+    .define_method(
+      "add_hint",
+      [](CpModelBuilder& self, IntVar var, int64_t value) {
+        self.AddHint(var, value);
+      })
+    .define_method(
+      "clear_hints",
+      [](CpModelBuilder& self) {
+        self.ClearHints();
+      })
+    .define_method(
+      "add_assumption",
+      [](CpModelBuilder& self, BoolVar lit) {
+        self.AddAssumption(lit);
+      })
+    .define_method(
+      "add_assumptions",
+      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+        self.AddAssumptions(literals);
+      })
+    .define_method(
+      "clear_assumptions",
+      [](CpModelBuilder& self) {
+        self.ClearAssumptions();
+      })
     .define_method(
       "to_s",
-      *[](CpModelBuilder& self) {
+      [](CpModelBuilder& self) {
         std::string proto_string;
         google::protobuf::TextFormat::PrintToString(self.Proto(), &proto_string);
         return proto_string;
       });
 
+  Rice::define_class_under<CpSolverResponse>(m, "CpSolverResponse")
+    .define_method("objective_value", &CpSolverResponse::objective_value)
+    .define_method("num_conflicts", &CpSolverResponse::num_conflicts)
+    .define_method("num_branches", &CpSolverResponse::num_branches)
+    .define_method("wall_time", &CpSolverResponse::wall_time)
+    .define_method(
+      "solution_integer_value",
+      [](CpSolverResponse& self, IntVar& x) {
+        LinearExpr expr(x);
+        return SolutionIntegerValue(self, expr);
+      })
+    .define_method("solution_boolean_value", &SolutionBooleanValue)
+    .define_method(
+      "status",
+      [](CpSolverResponse& self) {
+        auto status = self.status();
+
+        if (status == CpSolverStatus::OPTIMAL) {
+          return Symbol("optimal");
+        } else if (status == CpSolverStatus::FEASIBLE) {
+          return Symbol("feasible");
+        } else if (status == CpSolverStatus::INFEASIBLE) {
+          return Symbol("infeasible");
+        } else if (status == CpSolverStatus::MODEL_INVALID) {
+          return Symbol("model_invalid");
+        } else if (status == CpSolverStatus::UNKNOWN) {
+          return Symbol("unknown");
+        } else {
+          throw std::runtime_error("Unknown solver status");
+        }
+      })
+    .define_method(
+      "sufficient_assumptions_for_infeasibility",
+      [](CpSolverResponse& self) {
+        auto a = Array();
+        auto assumptions = self.sufficient_assumptions_for_infeasibility();
+        for (const auto& v : assumptions) {
+          a.push(v);
+        }
+        return a;
+      });
+
   Rice::define_class_under(m, "CpSolver")
     .define_method(
       "_solve_with_observer",
-      *[](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback, bool all_solutions) {
+      [](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback, bool all_solutions) {
         Model m;
 
         if (all_solutions) {
@@ -373,51 +398,19 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "_solve",
-      *[](Object self, CpModelBuilder& model, SatParameters& parameters) {
+      [](Object self, CpModelBuilder& model, SatParameters& parameters) {
         Model m;
         m.Add(NewSatParameters(parameters));
         return SolveCpModel(model.Build(), &m);
       })
     .define_method(
       "_solution_integer_value",
-      *[](Object self, CpSolverResponse& response, IntVar& x) {
+      [](Object self, CpSolverResponse& response, IntVar& x) {
         return SolutionIntegerValue(response, x);
       })
     .define_method(
       "_solution_boolean_value",
-      *[](Object self, CpSolverResponse& response, BoolVar& x) {
+      [](Object self, CpSolverResponse& response, BoolVar& x) {
         return SolutionBooleanValue(response, x);
       });
-
-  Rice::define_class_under<CpSolverResponse>(m, "CpSolverResponse")
-    .define_method("objective_value", &CpSolverResponse::objective_value)
-    .define_method("num_conflicts", &CpSolverResponse::num_conflicts)
-    .define_method("num_branches", &CpSolverResponse::num_branches)
-    .define_method("wall_time", &CpSolverResponse::wall_time)
-    .define_method(
-      "solution_integer_value",
-      *[](CpSolverResponse& self, IntVar& x) {
-        LinearExpr expr(x);
-        return SolutionIntegerValue(self, expr);
-      })
-    .define_method("solution_boolean_value", &SolutionBooleanValue)
-    .define_method(
-      "status",
-      *[](CpSolverResponse& self) {
-        auto status = self.status();
-
-        if (status == CpSolverStatus::OPTIMAL) {
-          return Symbol("optimal");
-        } else if (status == CpSolverStatus::FEASIBLE) {
-          return Symbol("feasible");
-        } else if (status == CpSolverStatus::INFEASIBLE) {
-          return Symbol("infeasible");
-        } else if (status == CpSolverStatus::MODEL_INVALID) {
-          return Symbol("model_invalid");
-        } else if (status == CpSolverStatus::UNKNOWN) {
-          return Symbol("unknown");
-        } else {
-          throw std::runtime_error("Unknown solver status");
-        }
-      });
 }