or-tools 0.17.1 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d08782975a4c387d502318dbd8c9335166a42ab76807b13ba78c7b249d6c879
-  data.tar.gz: 1653c6a0bfac136e9bdbe22d6bc10bc24d699926d79963cb41777f9e90eb880f
+  metadata.gz: c2d774f3459e19c0fc640d1c60c05cb896edec872fafb765b1162e08c79e921b
+  data.tar.gz: 40199c012d102d861fe405d7e93e51bf5232bcb402fa563ee63de6fe00db5ec8
 SHA512:
-  metadata.gz: 582adf83f9dfcdfe426364a22efc2bdd8733b5582a4aa3bb0b720910bd4a5d75a8466937b6b8bfed892c655017d246da3953081d56533a15aac8ae10b1ec96c5
-  data.tar.gz: e97b40eefc43fd253d2da0ad17f02a923649502d294904d49d4a431d1adc44c23222c8a59d61e36142400478bb6e128c90d00bee8419f0294c47f29aba4c4a93
+  metadata.gz: ac775e43751213a80c29ac82f38487e287891243d96b26e622474c034c44683135e412b5caa86e47232c36b32f1bfafec4b7152cab9fc652c1384a399e002072
+  data.tar.gz: f3a47294fd32b8464e33e566b277936c9ed687b79dfd3fece814cd9d5247252395131ddaf79b05cc2db8c8a76ad1e19610e9a151d8aaa5ea72d5d8cbd76135bb

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 0.18.0 (2026-07-06)
+
+- Added support for releasing GVL
+- Added `stop_search` method to `CpSolverSolutionCallback`
+- Fixed error with `apply_locks` and `set_allowed_vehicles_for_index` methods
+- Removed `solve_with_solution_callback` and `search_for_all_solutions` methods
+- Dropped support for Ruby < 3.3
+
 ## 0.17.1 (2026-02-19)
 
 - Fixed error with Rice 4.11

data/README.md

@@ -93,15 +93,15 @@ Specify people and their availabililty
 people = [
   {
     availability: [
-      {starts_at: Time.parse("2025-01-01 08:00:00"), ends_at: Time.parse("2025-01-01 16:00:00")},
-      {starts_at: Time.parse("2025-01-02 08:00:00"), ends_at: Time.parse("2025-01-02 16:00:00")}
+      {starts_at: Time.parse("2026-01-01 08:00:00"), ends_at: Time.parse("2026-01-01 16:00:00")},
+      {starts_at: Time.parse("2026-01-02 08:00:00"), ends_at: Time.parse("2026-01-02 16:00:00")}
     ],
     max_hours: 40 # optional, applies to entire scheduling period
   },
   {
     availability: [
-      {starts_at: Time.parse("2025-01-01 08:00:00"), ends_at: Time.parse("2025-01-01 16:00:00")},
-      {starts_at: Time.parse("2025-01-03 08:00:00"), ends_at: Time.parse("2025-01-03 16:00:00")}
+      {starts_at: Time.parse("2026-01-01 08:00:00"), ends_at: Time.parse("2026-01-01 16:00:00")},
+      {starts_at: Time.parse("2026-01-03 08:00:00"), ends_at: Time.parse("2026-01-03 16:00:00")}
     ],
     max_hours: 20
   }
@@ -112,9 +112,9 @@ Specify shifts
 
 ```ruby
 shifts = [
-  {starts_at: Time.parse("2025-01-01 08:00:00"), ends_at: Time.parse("2025-01-01 16:00:00")},
-  {starts_at: Time.parse("2025-01-02 08:00:00"), ends_at: Time.parse("2025-01-02 16:00:00")},
-  {starts_at: Time.parse("2025-01-03 08:00:00"), ends_at: Time.parse("2025-01-03 16:00:00")}
+  {starts_at: Time.parse("2026-01-01 08:00:00"), ends_at: Time.parse("2026-01-01 16:00:00")},
+  {starts_at: Time.parse("2026-01-02 08:00:00"), ends_at: Time.parse("2026-01-02 16:00:00")},
+  {starts_at: Time.parse("2026-01-03 08:00:00"), ends_at: Time.parse("2026-01-03 16:00:00")}
 ]
 ```
 
@@ -537,7 +537,8 @@ end
 # invoke the solver
 solver = ORTools::CpSolver.new
 solution_printer = VarArraySolutionPrinter.new(letters)
-status = solver.search_for_all_solutions(model, solution_printer)
+solver.parameters.enumerate_all_solutions = true
+status = solver.solve(model, solution_printer)
 
 puts
 puts "Statistics"
@@ -598,7 +599,8 @@ end
 # call the solver and display the results
 solver = ORTools::CpSolver.new
 solution_printer = SolutionPrinter.new(queens)
-status = solver.search_for_all_solutions(model, solution_printer)
+solver.parameters.enumerate_all_solutions = true
+status = solver.solve(model, solution_printer)
 puts
 puts "Solutions found : %i" % solution_printer.solution_count
 ```
@@ -1887,11 +1889,13 @@ end
 
 # call the solver and display the results
 solver = ORTools::CpSolver.new
+solver.parameters.linearization_level = 0
+solver.parameters.enumerate_all_solutions = true
 a_few_solutions = 5.times.to_a
 solution_printer = NursesPartialSolutionPrinter.new(
   shifts, num_nurses, num_days, num_shifts, a_few_solutions
 )
-solver.search_for_all_solutions(model, solution_printer)
+solver.solve(model, solution_printer)
 
 puts
 puts "Statistics"

data/ext/or-tools/assignment.cpp

@@ -30,7 +30,7 @@ void init_assignment(Rice::Module& m) {
         } else if (status == SimpleLinearSumAssignment::Status::POSSIBLE_OVERFLOW) {
           return Symbol("possible_overflow");
         } else {
-          throw std::runtime_error("Unknown status");
+          throw std::runtime_error{"Unknown status"};
         }
       });
 }

data/ext/or-tools/bin_packing.cpp

@@ -27,11 +27,11 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     KnapsackSolver::SolverType convert(VALUE x) {
-      auto s = Symbol(x).str();
+      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);
+        throw std::runtime_error{"Unknown solver type: " + s};
       }
     }
 
@@ -47,7 +47,7 @@ void init_bin_packing(Rice::Module& m) {
     .define_method("best_solution_contains?", &KnapsackSolver::BestSolutionContains)
     .define_method(
       "init",
-       [](KnapsackSolver& self, std::vector<int64_t> values, std::vector<std::vector<int64_t>> weights, std::vector<int64_t> capacities) {
+       [](KnapsackSolver& self, const std::vector<int64_t>& values, const std::vector<std::vector<int64_t>>& weights, const std::vector<int64_t>& capacities) {
         self.Init(values, weights, capacities);
       });
 }

data/ext/or-tools/channel.hpp

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <chrono>
+#include <condition_variable>
+#include <mutex>
+#include <optional>
+#include <queue>
+
+template<typename T>
+class Channel {
+  std::queue<T> queue;
+  std::mutex mutex;
+  std::condition_variable cv;
+
+public:
+  void send(T message) {
+    std::lock_guard<std::mutex> guard(mutex);
+    queue.push(std::move(message));
+    cv.notify_one();
+  }
+
+  template<typename U, typename V>
+  std::optional<T> recv_timeout(const std::chrono::duration<U, V>& duration) {
+    std::unique_lock<std::mutex> lock(mutex);
+    if (!cv.wait_for(lock, duration, [&] { return !queue.empty(); })) {
+      return std::nullopt;
+    }
+    T message = std::move(queue.front());
+    queue.pop();
+    return message;
+  }
+
+  bool empty() {
+    std::lock_guard<std::mutex> guard(mutex);
+    return queue.empty();
+  }
+};

data/ext/or-tools/constraint.cpp

@@ -1,3 +1,6 @@
+#include <atomic>
+#include <chrono>
+#include <optional>
 #include <string>
 #include <vector>
 
@@ -6,21 +9,23 @@
 #include <rice/rice.hpp>
 #include <rice/stl.hpp>
 
+#include "channel.hpp"
+
 using operations_research::Domain;
 using operations_research::sat::BoolVar;
 using operations_research::sat::Constraint;
-using operations_research::sat::TableConstraint;
 using operations_research::sat::CpModelBuilder;
 using operations_research::sat::CpSolverResponse;
 using operations_research::sat::CpSolverStatus;
-using operations_research::sat::LinearExpr;
-using operations_research::sat::IntVar;
 using operations_research::sat::IntervalVar;
+using operations_research::sat::IntVar;
+using operations_research::sat::LinearExpr;
 using operations_research::sat::Model;
 using operations_research::sat::NewFeasibleSolutionObserver;
 using operations_research::sat::SatParameters;
 using operations_research::sat::SolutionBooleanValue;
 using operations_research::sat::SolutionIntegerValue;
+using operations_research::sat::TableConstraint;
 
 using Rice::Array;
 using Rice::Class;
@@ -131,37 +136,18 @@ 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) {
-        self.set_max_time_in_seconds(value);
-      })
-    .define_method(
-      "enumerate_all_solutions=",
-      [](SatParameters& self, bool value) {
-        self.set_enumerate_all_solutions(value);
-      })
-    .define_method(
-      "enumerate_all_solutions",
-      [](SatParameters& self) {
-        return self.enumerate_all_solutions();
-       })
-    .define_method("num_workers=",
-      [](SatParameters& self, int32_t value){
-        self.set_num_workers(value);
-      })
-    .define_method("cp_model_presolve=",
-      [](SatParameters& self, bool value) {
-        self.set_cp_model_presolve(value);
-      })
-    .define_method("random_seed",
-      [](SatParameters& self) {
-        return self.random_seed();
-      })
-    .define_method("random_seed=",
-      [](SatParameters& self, int32_t value) {
-        self.set_random_seed(value);
-      });
+    .define_method("cp_model_presolve", &SatParameters::cp_model_presolve)
+    .define_method("cp_model_presolve=", &SatParameters::set_cp_model_presolve)
+    .define_method("enumerate_all_solutions", &SatParameters::enumerate_all_solutions)
+    .define_method("enumerate_all_solutions=", &SatParameters::set_enumerate_all_solutions)
+    .define_method("linearization_level", &SatParameters::linearization_level)
+    .define_method("linearization_level=", &SatParameters::set_linearization_level)
+    .define_method("max_time_in_seconds", &SatParameters::max_time_in_seconds)
+    .define_method("max_time_in_seconds=", &SatParameters::set_max_time_in_seconds)
+    .define_method("num_workers", &SatParameters::num_workers)
+    .define_method("num_workers=", &SatParameters::set_num_workers)
+    .define_method("random_seed", &SatParameters::random_seed)
+    .define_method("random_seed=", &SatParameters::set_random_seed);
 
   Rice::define_class_under<CpModelBuilder>(m, "CpModel")
     .define_constructor(Rice::Constructor<CpModelBuilder>())
@@ -193,32 +179,32 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "new_interval_var",
-      [](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, const std::string& name) {
+      [](CpModelBuilder& self, const IntVar& start, const IntVar& size, const 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, const std::string& name) {
+      [](CpModelBuilder& self, const IntVar& start, const IntVar& size, const IntVar& end, const BoolVar& presence, const std::string& name) {
         return self.NewOptionalIntervalVar(start, size, end, presence).WithName(name);
       })
     .define_method(
       "add_bool_or",
-      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+      [](CpModelBuilder& self, const std::vector<BoolVar>& literals) {
         return self.AddBoolOr(literals);
       })
     .define_method(
       "add_bool_and",
-      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+      [](CpModelBuilder& self, const std::vector<BoolVar>& literals) {
         return self.AddBoolAnd(literals);
       })
     .define_method(
       "add_bool_xor",
-      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+      [](CpModelBuilder& self, const std::vector<BoolVar>& literals) {
         return self.AddBoolXor(literals);
       })
     .define_method(
       "add_implication",
-      [](CpModelBuilder& self, BoolVar a, BoolVar b) {
+      [](CpModelBuilder& self, const BoolVar& a, const BoolVar& b) {
         return self.AddImplication(a, b);
       })
     .define_method(
@@ -253,7 +239,7 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "add_linear_expression_in_domain",
-      [](CpModelBuilder& self, LinearExpr expr, Domain domain) {
+      [](CpModelBuilder& self, LinearExpr expr, const Domain& domain) {
         return self.AddLinearConstraint(expr, domain);
       })
     .define_method(
@@ -263,7 +249,7 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "add_all_different",
-      [](CpModelBuilder& self, std::vector<IntVar> vars) {
+      [](CpModelBuilder& self, const std::vector<IntVar>& vars) {
         return self.AddAllDifferent(vars);
       })
     .define_method(
@@ -278,7 +264,7 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "add_inverse_constraint",
-      [](CpModelBuilder& self, std::vector<IntVar> variables, std::vector<IntVar> inverse_variables) {
+      [](CpModelBuilder& self, const std::vector<IntVar>& variables, const std::vector<IntVar>& inverse_variables) {
         return self.AddInverseConstraint(variables, inverse_variables);
       })
     .define_method(
@@ -313,7 +299,7 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "add_no_overlap",
-      [](CpModelBuilder& self, std::vector<IntervalVar> vars) {
+      [](CpModelBuilder& self, const std::vector<IntervalVar>& vars) {
         return self.AddNoOverlap(vars);
       })
     .define_method(
@@ -348,12 +334,12 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "add_assumption",
-      [](CpModelBuilder& self, BoolVar lit) {
+      [](CpModelBuilder& self, const BoolVar& lit) {
         self.AddAssumption(lit);
       })
     .define_method(
       "add_assumptions",
-      [](CpModelBuilder& self, std::vector<BoolVar> literals) {
+      [](CpModelBuilder& self, const std::vector<BoolVar>& literals) {
         self.AddAssumptions(literals);
       })
     .define_method(
@@ -370,7 +356,9 @@ void init_constraint(Rice::Module& m) {
       "to_s",
       [](CpModelBuilder& self) {
         std::string proto_string;
-        google::protobuf::TextFormat::PrintToString(self.Proto(), &proto_string);
+        if (!google::protobuf::TextFormat::PrintToString(self.Proto(), &proto_string)) {
+          throw Rice::Exception(rb_eRuntimeError, "PrintToString failed");
+        }
         return proto_string;
       });
 
@@ -402,7 +390,7 @@ void init_constraint(Rice::Module& m) {
         } else if (status == CpSolverStatus::UNKNOWN) {
           return Symbol("unknown");
         } else {
-          throw std::runtime_error("Unknown solver status");
+          throw std::runtime_error{"Unknown solver status"};
         }
       })
     .define_method(
@@ -426,34 +414,105 @@ void init_constraint(Rice::Module& m) {
       "_solve",
       [](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback) {
         Model m;
+        m.Add(NewSatParameters(parameters));
 
-        if (!callback.is_nil()) {
-          // use a single worker since Ruby code cannot be run in a non-Ruby thread
-          parameters.set_num_search_workers(1);
+        std::atomic<bool> done{false};
+        Channel<CpSolverResponse> channel;
+        Rice::Object ruby_thread;
+        std::optional<Rice::Exception> exception;
 
-          m.Add(NewFeasibleSolutionObserver(
-            [&callback](const CpSolverResponse& r) {
-              if (!ruby_native_thread_p()) {
-                throw std::runtime_error("Non-Ruby thread");
+        auto with_gvl = [](std::function<void()> f) {
+          auto ruby_wrapper = [](void* arg) -> void* {
+            (*static_cast<decltype(f)*>(arg))();
+            return nullptr;
+          };
+          rb_thread_call_with_gvl(ruby_wrapper, &f);
+        };
+
+        auto ruby_observer = [&]() {
+          return Rice::detail::no_gvl([&]() {
+            while (true) {
+              if (done.load() && channel.empty()) {
+                break;
+              }
+
+              while (true) {
+                std::optional<CpSolverResponse> response = channel.recv_timeout(std::chrono::milliseconds(10));
+                if (!response) {
+                  break;
+                }
+
+                bool stop = false;
+                with_gvl([&]() {
+                  try {
+                    try {
+                      callback.call("response=", response.value());
+                      callback.call("on_solution_callback");
+                      stop = static_cast<bool>(callback.attr_get("@stopped"));
+                    } catch (const Rice::Exception& e) {
+                      exception = e;
+                      stop = true;
+                    }
+                    callback.call("response=", Object(Qnil));
+                  } catch (const Rice::Exception& e) {
+                    exception = e;
+                    stop = true;
+                  }
+                });
+
+                if (stop) {
+                  StopSearch(&m);
+                  return Qnil;
+                }
               }
 
-              callback.call("response=", r);
-              callback.call("on_solution_callback");
+              with_gvl([]() {
+                Rice::detail::protect(rb_thread_schedule);
+              });
+            }
+            return Qnil;
+          });
+        };
+
+        auto ruby_wrapper = [](void* arg) {
+          return (*static_cast<decltype(ruby_observer)*>(arg))();
+        };
+
+        if (!callback.is_nil()) {
+          ruby_thread = Rice::detail::protect([&]() {
+            return rb_thread_create(ruby_wrapper, &ruby_observer);
+          });
+
+          m.Add(NewFeasibleSolutionObserver(
+            [&](const CpSolverResponse& response) {
+              channel.send(response);
             })
           );
         }
 
-        m.Add(NewSatParameters(parameters));
-        return SolveCpModel(model.Build(), &m);
+        CpSolverResponse response = Rice::detail::no_gvl([&]() {
+          return SolveCpModel(model.Build(), &m);
+        });
+
+        if (!callback.is_nil()) {
+          done = true;
+          ruby_thread.call("value");
+
+          if (exception.has_value()) {
+            throw exception.value();
+          }
+        }
+
+        return response;
       })
     .define_method(
       "_solution_integer_value",
-      [](Object self, const CpSolverResponse& response, IntVar x) {
+      [](Object self, const CpSolverResponse& response, const IntVar& x) {
         return SolutionIntegerValue(response, x);
       })
     .define_method(
       "_solution_boolean_value",
-      [](Object self, const CpSolverResponse& response, BoolVar x) {
+      [](Object self, const CpSolverResponse& response, const BoolVar& x) {
         return SolutionBooleanValue(response, x);
       });
 }

data/ext/or-tools/ext.cpp

@@ -16,7 +16,7 @@ void init_routing(Rice::Module& m);
 
 extern "C"
 void Init_ext() {
-  auto m = Rice::define_module("ORTools");
+  Rice::Module m = Rice::define_module("ORTools");
 
   m.define_singleton_function("lib_version", &operations_research::OrToolsVersionString);
 

data/ext/or-tools/linear.cpp

@@ -8,8 +8,8 @@
 
 using operations_research::MPConstraint;
 using operations_research::MPObjective;
-using operations_research::MPSolverParameters;
 using operations_research::MPSolver;
+using operations_research::MPSolverParameters;
 using operations_research::MPVariable;
 
 using Rice::Array;
@@ -34,13 +34,13 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     static MPSolver::OptimizationProblemType convert(VALUE x) {
-      auto s = Symbol(x).str();
+      std::string s = Symbol(x).str();
       if (s == "glop") {
         return MPSolver::OptimizationProblemType::GLOP_LINEAR_PROGRAMMING;
       } else if (s == "cbc") {
         return MPSolver::OptimizationProblemType::CBC_MIXED_INTEGER_PROGRAMMING;
       } else {
-        throw std::runtime_error("Unknown optimization problem type: " + s);
+        throw std::runtime_error{"Unknown optimization problem type: " + s};
       }
     }
 
@@ -175,7 +175,7 @@ void init_linear(Rice::Module& m) {
       [](const std::string& name, MPSolver::OptimizationProblemType problem_type) {
         MPSolver* solver = new MPSolver(name, problem_type);
         if (!solver) {
-          throw std::runtime_error("Unrecognized solver type");
+          throw std::runtime_error{"Unrecognized solver type"};
         }
         return solver;
       }, Rice::Return().takeOwnership())
@@ -184,7 +184,7 @@ void init_linear(Rice::Module& m) {
       [](const std::string& solver_id) {
         MPSolver* solver = MPSolver::CreateSolver(solver_id);
         if (!solver) {
-          throw std::runtime_error("Unrecognized solver type");
+          throw std::runtime_error{"Unrecognized solver type"};
         }
         return solver;
       }, Rice::Return().takeOwnership())
@@ -239,7 +239,7 @@ void init_linear(Rice::Module& m) {
         } else if (status == MPSolver::ResultStatus::NOT_SOLVED) {
           return Symbol("not_solved");
         } else {
-          throw std::runtime_error("Unknown status");
+          throw std::runtime_error{"Unknown status"};
         }
       })
     .define_method(
@@ -247,7 +247,7 @@ void init_linear(Rice::Module& m) {
       [](MPSolver& self, bool obfuscate) {
         std::string model_str;
         if (!self.ExportModelAsLpFormat(obfuscate, &model_str)) {
-          throw std::runtime_error("Export failed");
+          throw std::runtime_error{"Export failed"};
         }
         return model_str;
       })
@@ -256,7 +256,7 @@ void init_linear(Rice::Module& m) {
       [](MPSolver& self, bool fixed_format, bool obfuscate) {
         std::string model_str;
         if (!self.ExportModelAsMpsFormat(fixed_format, obfuscate, &model_str)) {
-          throw std::runtime_error("Export failed");
+          throw std::runtime_error{"Export failed"};
         }
         return model_str;
       });

data/ext/or-tools/math_opt.cpp

@@ -32,7 +32,7 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     static SolverType convert(VALUE x) {
-      auto s = Symbol(x).str();
+      std::string s = Symbol(x).str();
       if (s == "gscip") {
         return SolverType::kGscip;
       } else if (s == "gurobi") {
@@ -54,7 +54,7 @@ namespace Rice::detail {
       } else if (s == "santorini") {
         return SolverType::kSantorini;
       } else {
-        throw std::runtime_error("Unknown solver type: " + s);
+        throw std::runtime_error{"Unknown solver type: " + s};
       }
     }
 
@@ -71,11 +71,11 @@ void init_math_opt(Rice::Module& m) {
     .define_method(
       "name",
       [](Variable& self) {
-        return std::string(self.name());
+        return std::string{self.name()};
       })
     .define_method(
       "_eql?",
-      [](Variable& self, Variable &other) {
+      [](Variable& self, Variable& other) {
         return static_cast<bool>(self == other);
       });
 
@@ -106,7 +106,7 @@ void init_math_opt(Rice::Module& m) {
         } else if (reason == TerminationReason::kOtherError) {
           return Rice::Symbol("other");
         } else {
-          throw std::runtime_error("Unknown termination reason");
+          throw std::runtime_error{"Unknown termination reason"};
         }
       });
 
@@ -143,18 +143,18 @@ void init_math_opt(Rice::Module& m) {
       })
     .define_method(
       "_set_upper_bound",
-      [](Model& self, LinearConstraint constraint, double upper_bound) {
+      [](Model& self, const LinearConstraint& constraint, double upper_bound) {
         self.set_upper_bound(constraint, upper_bound);
       })
     .define_method(
       "_set_lower_bound",
-      [](Model& self, LinearConstraint constraint, double upper_bound) {
+      [](Model& self, const LinearConstraint& constraint, double upper_bound) {
         self.set_lower_bound(constraint, upper_bound);
       })
     .define_method("_set_coefficient", &Model::set_coefficient)
     .define_method(
       "_set_objective_coefficient",
-      [](Model& self, Variable variable, double value) {
+      [](Model& self, const Variable& variable, double value) {
         self.set_objective_coefficient(variable, value);
       })
     .define_method("_clear_objective", &Model::clear_objective)

data/ext/or-tools/network_flows.cpp

@@ -36,7 +36,7 @@ void init_network_flows(Rice::Module& m) {
         } else if (status == SimpleMaxFlow::Status::BAD_RESULT) {
           return Symbol("bad_result");
         } else {
-          throw std::runtime_error("Unknown status");
+          throw std::runtime_error{"Unknown status"};
         }
       })
     .define_method(
@@ -98,7 +98,7 @@ void init_network_flows(Rice::Module& m) {
         } else if (status == SimpleMinCostFlow::Status::BAD_COST_RANGE) {
           return Symbol("bad_cost_range");
         } else {
-          throw std::runtime_error("Unknown status");
+          throw std::runtime_error{"Unknown status"};
         }
       });
 }

data/ext/or-tools/routing.cpp

@@ -58,7 +58,7 @@ namespace Rice::detail {
 
     explicit To_Ruby(Arg* arg) : arg_(arg) { }
 
-    VALUE convert(RoutingNodeIndex const & x) {
+    VALUE convert(const RoutingNodeIndex& x) {
       return To_Ruby<int>().convert(x.value());
     }
 
@@ -81,13 +81,13 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     RoutingModel::PenaltyCostBehavior convert(VALUE x) {
-      auto s = Symbol(x).str();
+      std::string s = Symbol(x).str();
       if (s == "penalize_once") {
         return RoutingModel::PenaltyCostBehavior::PENALIZE_ONCE;
       } else if (s == "penalize_per_inactive") {
         return RoutingModel::PenaltyCostBehavior::PENALIZE_PER_INACTIVE;
       } else {
-        throw std::runtime_error("Unknown penalty cost behavior: " + s);
+        throw std::runtime_error{"Unknown penalty cost behavior: " + s};
       }
     }
 
@@ -138,7 +138,7 @@ void init_routing(Rice::Module& m) {
         } else if (s == "first_unbound_min_value") {
           v = FirstSolutionStrategy::FIRST_UNBOUND_MIN_VALUE;
         } else {
-          throw std::runtime_error("Unknown first solution strategy: " + s);
+          throw std::runtime_error{"Unknown first solution strategy: " + s};
         }
 
         return self.set_first_solution_strategy(v);
@@ -158,7 +158,7 @@ void init_routing(Rice::Module& m) {
         } else if (s == "simulated_annealing") {
           v = LocalSearchMetaheuristic::SIMULATED_ANNEALING;
         } else {
-          throw std::runtime_error("Unknown local search metaheuristic: " + s);
+          throw std::runtime_error{"Unknown local search metaheuristic: " + s};
         }
 
         return self.set_local_search_metaheuristic(v);
@@ -192,7 +192,7 @@ void init_routing(Rice::Module& m) {
       })
     .define_singleton_function(
       "_new_starts_ends",
-      [](int num_nodes, int num_vehicles, std::vector<RoutingNodeIndex> starts, std::vector<RoutingNodeIndex> ends) {
+      [](int num_nodes, int num_vehicles, const std::vector<RoutingNodeIndex>& starts, const std::vector<RoutingNodeIndex>& ends) {
         return RoutingIndexManager(num_nodes, num_vehicles, starts, ends);
       })
     .define_method("index_to_node", &RoutingIndexManager::IndexToNode)
@@ -273,13 +273,13 @@ void init_routing(Rice::Module& m) {
         if (o.respond_to("left")) {
           operations_research::IntExpr* left(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("left")));
           operations_research::IntExpr* right(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("right")));
-          auto op = o.call("op").to_s().str();
+          std::string op = o.call("op").to_s().str();
           if (op == "==") {
             constraint = self.MakeEquality(left, right);
           } else if (op == "<=") {
             constraint = self.MakeLessOrEqual(left, right);
           } else {
-            throw std::runtime_error("Unknown operator");
+            throw std::runtime_error{"Unknown operator"};
           }
         } else {
           constraint = Rice::detail::From_Ruby<operations_research::Constraint*>().convert(o);
@@ -288,12 +288,12 @@ void init_routing(Rice::Module& m) {
       })
     .define_method(
       "fixed_duration_interval_var",
-      [](operations_research::Solver& self, operations_research::IntVar* const start_variable, int64_t duration, const std::string& name) {
-        return self.MakeFixedDurationIntervalVar(start_variable, duration, name);
+      [](operations_research::Solver& self, operations_research::IntVar& start_variable, int64_t duration, const std::string& name) {
+        return self.MakeFixedDurationIntervalVar(&start_variable, duration, name);
       })
     .define_method(
       "cumulative",
-      [](operations_research::Solver& self, Array rb_intervals, std::vector<int64_t> demands, int64_t capacity, const std::string& name) {
+      [](operations_research::Solver& self, Array rb_intervals, const std::vector<int64_t>& demands, int64_t capacity, const std::string& name) {
         std::vector<operations_research::IntervalVar*> intervals;
         for (const auto& v : rb_intervals) {
           intervals.push_back(Rice::detail::From_Ruby<operations_research::IntervalVar*>().convert(v.value()));
@@ -332,13 +332,13 @@ void init_routing(Rice::Module& m) {
     .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager, RoutingModelParameters>(), Rice::Arg("_index_manager"), Rice::Arg("_parameters") = operations_research::DefaultRoutingModelParameters())
     .define_method("register_unary_transit_vector", &RoutingModel::RegisterUnaryTransitVector)
     .define_method(
-      "register_unary_transit_callback",
+      "_register_unary_transit_callback",
       [](RoutingModel& self, Object callback) {
         // TODO guard callback?
         return self.RegisterUnaryTransitCallback(
           [callback](int64_t from_index) -> int64_t {
             if (!ruby_native_thread_p()) {
-              throw std::runtime_error("Non-Ruby thread");
+              throw std::runtime_error{"Non-Ruby thread"};
             }
 
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
@@ -347,13 +347,13 @@ void init_routing(Rice::Module& m) {
       }, Rice::Arg("_callback").keepAlive())
     .define_method("register_transit_matrix", &RoutingModel::RegisterTransitMatrix)
     .define_method(
-      "register_transit_callback",
+      "_register_transit_callback",
       [](RoutingModel& self, Object callback) {
         // TODO guard callback?
         return self.RegisterTransitCallback(
           [callback](int64_t from_index, int64_t to_index) -> int64_t {
             if (!ruby_native_thread_p()) {
-              throw std::runtime_error("Non-Ruby thread");
+              throw std::runtime_error{"Non-Ruby thread"};
             }
 
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
@@ -386,7 +386,11 @@ void init_routing(Rice::Module& m) {
     .define_method("perfect_binary_disjunctions", &RoutingModel::GetPerfectBinaryDisjunctions)
     .define_method("ignore_disjunctions_already_forced_to_zero", &RoutingModel::IgnoreDisjunctionsAlreadyForcedToZero)
     .define_method("add_soft_same_vehicle_constraint", &RoutingModel::AddSoftSameVehicleConstraint)
-    .define_method("set_allowed_vehicles_for_index", &RoutingModel::SetAllowedVehiclesForIndex)
+    .define_method(
+      "set_allowed_vehicles_for_index",
+      [](RoutingModel& self, const std::vector<int>& vehicles, int64_t index) {
+        self.SetAllowedVehiclesForIndex(vehicles, index);
+      })
     .define_method("vehicle_allowed_for_index?", &RoutingModel::IsVehicleAllowedForIndex)
     .define_method("add_pickup_and_delivery", &RoutingModel::AddPickupAndDelivery)
     .define_method("add_pickup_and_delivery_sets", &RoutingModel::AddPickupAndDeliverySets)
@@ -426,14 +430,26 @@ void init_routing(Rice::Module& m) {
     .define_method("close_model", &RoutingModel::CloseModel)
     // solve defined in Ruby
     .define_method(
-      "solve_with_parameters",
-      [](RoutingModel& self, const RoutingSearchParameters& search_parameters) {
-        return self.SolveWithParameters(search_parameters);
+      "_solve_with_parameters",
+      [](RoutingModel& self, const RoutingSearchParameters& search_parameters, bool release_gvl) {
+        if (release_gvl) {
+          return Rice::detail::no_gvl([&]() {
+            return self.SolveWithParameters(search_parameters);
+          });
+        } else {
+          return self.SolveWithParameters(search_parameters);
+        }
       })
     .define_method(
-      "solve_from_assignment_with_parameters",
-      [](RoutingModel& self, const Assignment* assignment, const RoutingSearchParameters& search_parameters) {
-        return self.SolveFromAssignmentWithParameters(assignment, search_parameters);
+      "_solve_from_assignment_with_parameters",
+      [](RoutingModel& self, const Assignment& assignment, const RoutingSearchParameters& search_parameters, bool release_gvl) {
+        if (release_gvl) {
+          return Rice::detail::no_gvl([&]() {
+            return self.SolveFromAssignmentWithParameters(&assignment, search_parameters);
+          });
+        } else {
+          return self.SolveFromAssignmentWithParameters(&assignment, search_parameters);
+        }
       })
     .define_method("compute_lower_bound", &RoutingModel::ComputeLowerBound)
     .define_method("status",
@@ -451,10 +467,14 @@ void init_routing(Rice::Module& m) {
         } else if (status == RoutingSearchStatus::ROUTING_INVALID) {
           return Symbol("invalid");
         } else {
-          throw std::runtime_error("Unknown solver status");
+          throw std::runtime_error{"Unknown solver status"};
         }
       })
-    .define_method("apply_locks", &RoutingModel::ApplyLocks)
+    .define_method(
+      "apply_locks",
+      [](RoutingModel& self, const std::vector<int64_t>& locks) {
+        return self.ApplyLocks(locks);
+      })
     .define_method("apply_locks_to_all_vehicles", &RoutingModel::ApplyLocksToAllVehicles)
     .define_method("pre_assignment", &RoutingModel::PreAssignment)
     .define_method("mutable_pre_assignment", &RoutingModel::MutablePreAssignment)

data/ext/or-tools/vendor.rb

@@ -1,6 +1,6 @@
 require "digest"
 require "fileutils"
-require "net/http"
+require "open-uri"
 require "tmpdir"
 
 version = "9.15.6755"
@@ -70,62 +70,31 @@ end
 short_version = version.split(".").first(2).join(".")
 url = "https://github.com/google/or-tools/releases/download/v#{short_version}/#{filename}"
 
-$stdout.sync = true
-
-def download_file(url, download_path, redirects = 0)
-  raise "Too many redirects" if redirects > 10
-
-  uri = URI(url)
-  location = nil
-
-  Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
-    request = Net::HTTP::Get.new(uri)
-    http.request(request) do |response|
-      case response
-      when Net::HTTPRedirection
-        location = response["location"]
-      when Net::HTTPSuccess
-        i = 0
-        File.open(download_path, "wb") do |f|
-          response.read_body do |chunk|
-            f.write(chunk)
-
-            # print progress
-            putc "." if i % 50 == 0
-            i += 1
-          end
-        end
-        puts # newline
-      else
-        raise "Bad response"
-      end
-    end
-  end
-
-  # outside of Net::HTTP block to close previous connection
-  download_file(location, download_path, redirects + 1) if location
-end
-
-# download
-download_path = "#{Dir.tmpdir}/#{filename}"
-unless File.exist?(download_path)
-  puts "Downloading #{url}..."
-  download_file(url, download_path)
-end
-
-# check integrity - do this regardless of if just downloaded
-download_checksum = Digest::SHA256.file(download_path).hexdigest
-raise "Bad checksum: #{download_checksum}" if download_checksum != checksum
-
 path = File.expand_path("../../tmp/or-tools", __dir__)
 FileUtils.mkdir_p(path)
 
-# extract - can't use Gem::Package#extract_tar_gz from RubyGems
-# since it limits filenames to 100 characters (doesn't support UStar format)
-# for space, only keep licenses, include, and shared library
 Dir.mktmpdir do |extract_path|
-  tar_args = Gem.win_platform? ? ["--force-local"] : []
-  system "tar", "zxf", download_path, "-C", extract_path, "--strip-components=1", *tar_args
+  # download
+  puts "Downloading #{url}..."
+  URI.parse(url).open(max_redirects: 10) do |download|
+    download_checksum =
+      if download.respond_to?(:path)
+        download.flush
+        Digest::SHA256.file(download.path).hexdigest
+      else
+        Digest::SHA256.hexdigest(download.string)
+      end
+    raise "Bad checksum: #{download_checksum}" if download_checksum != checksum
+
+    # should never happen
+    raise "Expected file" if !download.respond_to?(:path)
+
+    # extract - can't use Gem::Package#extract_tar_gz from RubyGems
+    # since it limits filenames to 100 characters (doesn't support UStar format)
+    # for space, only keep licenses, include, and shared library
+    tar_args = Gem.win_platform? ? ["--force-local"] : []
+    system "tar", "zxf", download.path, "-C", extract_path, "--strip-components=1", *tar_args
+  end
 
   # include
   FileUtils.mv(File.join(extract_path, "include"), File.join(path, "include"))

data/lib/or_tools/cp_solver.rb

@@ -8,6 +8,7 @@ module ORTools
 
     def solve(model, observer = nil)
       @response = _solve(model, parameters, observer)
+      observer.response = @response if observer
       @response.status
     end
 
@@ -25,22 +26,6 @@ module ORTools
       end
     end
 
-    def solve_with_solution_callback(model, observer)
-      warn "[or-tools] solve_with_solution_callback is deprecated; use solve(model, callback)"
-      solve(model, observer)
-    end
-
-    def search_for_all_solutions(model, observer)
-      warn "[or-tools] search_for_all_solutions is deprecated; use solve() with solver.parameters.enumerate_all_solutions = true"
-      previous_value = parameters.enumerate_all_solutions
-      begin
-        parameters.enumerate_all_solutions = true
-        solve(model, observer)
-      ensure
-        parameters.enumerate_all_solutions = previous_value
-      end
-    end
-
     def solution_info
       @response.solution_info
     end

data/lib/or_tools/cp_solver_solution_callback.rb

@@ -16,5 +16,9 @@ module ORTools
     def objective_value
       @response&.objective_value
     end
+
+    def stop_search
+      @stopped = true
+    end
   end
 end

data/lib/or_tools/routing_model.rb

@@ -21,5 +21,23 @@ module ORTools
     def add_disjunction(indices, penalty, max_cardinality = 1, penalty_cost_behavior = :penalize_once)
       _add_disjunction(indices, penalty, max_cardinality, penalty_cost_behavior)
     end
+
+    def solve_with_parameters(search_parameters)
+      _solve_with_parameters(search_parameters, !@ruby_callback)
+    end
+
+    def solve_from_assignment_with_parameters(assignment, search_parameters)
+      _solve_from_assignment_with_parameters(assignment, search_parameters, !@ruby_callback)
+    end
+
+    def register_unary_transit_callback(callback)
+      @ruby_callback = true
+      _register_unary_transit_callback(callback)
+    end
+
+    def register_transit_callback(callback)
+      @ruby_callback = true
+      _register_transit_callback(callback)
+    end
   end
 end

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.17.1"
+  VERSION = "0.18.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.17.1
+  version: 0.18.0
 platform: ruby
 authors:
 - Andrew Kane
@@ -35,6 +35,7 @@ files:
 - README.md
 - ext/or-tools/assignment.cpp
 - ext/or-tools/bin_packing.cpp
+- ext/or-tools/channel.hpp
 - ext/or-tools/constraint.cpp
 - ext/or-tools/ext.cpp
 - ext/or-tools/extconf.rb
@@ -78,14 +79,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.1'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.14
 specification_version: 4
 summary: Operations research tools for Ruby
 test_files: []