or-tools 0.17.1 → 0.18.1

data/ext/or-tools/routing.cpp

@@ -10,6 +10,7 @@ using operations_research::Assignment;
 using operations_research::ConstraintSolverParameters;
 using operations_research::DefaultRoutingSearchParameters;
 using operations_research::FirstSolutionStrategy;
+using operations_research::IntervalVarElement;
 using operations_research::LocalSearchMetaheuristic;
 using operations_research::RoutingDimension;
 using operations_research::RoutingDisjunctionIndex;
@@ -22,6 +23,7 @@ using operations_research::RoutingSearchStatus;
 
 using Rice::Array;
 using Rice::Class;
+using Rice::Hash;
 using Rice::Module;
 using Rice::Object;
 using Rice::String;
@@ -58,7 +60,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 +83,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};
       }
     }
 
@@ -96,13 +98,111 @@ namespace Rice::detail {
   };
 } // namespace Rice::detail
 
+int64_t int64_strict(VALUE v) {
+  if (!Object(v).is_a(rb_cInteger)) {
+    throw std::invalid_argument{"Coefficient must be integer"};
+  }
+  return Rice::detail::From_Ruby<int64_t>().convert(v);
+}
+
+operations_research::IntExpr* int_expr(operations_research::Solver& solver, Object o) {
+    Object utils = Rice::define_module("ORTools").const_get("Utils");
+    Hash rb_coeffs = utils.call("index_expression", o);
+
+    std::vector<operations_research::IntVar*> vars;
+    std::vector<int64_t> coeffs;
+    int64_t constant = 0;
+
+    for (const auto& entry : rb_coeffs) {
+      auto coeff = int64_strict(entry.value.value());
+      if (Object(entry.key).is_nil()) {
+        constant = coeff;
+      } else {
+        vars.push_back(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(entry.key.value()));
+        coeffs.push_back(coeff);
+      }
+    }
+
+    operations_research::IntExpr* expr = solver.MakeScalProd(vars, coeffs);
+    if (constant != 0) {
+      expr = solver.MakeSum(expr, constant);
+    }
+    return expr;
+}
+
 void init_routing(Rice::Module& m) {
   auto rb_cRoutingSearchParameters = Rice::define_class_under<RoutingSearchParameters>(m, "RoutingSearchParameters");
   auto rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "RoutingIntVar");
 
   m.define_singleton_function("default_routing_search_parameters", &DefaultRoutingSearchParameters);
 
+  Rice::define_class_under<RoutingSearchParameters::ImprovementSearchLimitParameters>(rb_cRoutingSearchParameters, "ImprovementSearchLimitParameters")
+    .define_method("improvement_rate_coefficient", &RoutingSearchParameters::ImprovementSearchLimitParameters::improvement_rate_coefficient)
+    .define_method("improvement_rate_coefficient=", &RoutingSearchParameters::ImprovementSearchLimitParameters::set_improvement_rate_coefficient)
+    .define_method("improvement_rate_solutions_distance", &RoutingSearchParameters::ImprovementSearchLimitParameters::improvement_rate_solutions_distance)
+    .define_method("improvement_rate_solutions_distance=", &RoutingSearchParameters::ImprovementSearchLimitParameters::set_improvement_rate_solutions_distance);
+
   rb_cRoutingSearchParameters
+    .define_method("christofides_use_minimum_matching", &RoutingSearchParameters::christofides_use_minimum_matching)
+    .define_method("christofides_use_minimum_matching=", &RoutingSearchParameters::set_christofides_use_minimum_matching)
+    .define_method("fallback_to_cp_sat_size_threshold", &RoutingSearchParameters::fallback_to_cp_sat_size_threshold)
+    .define_method("fallback_to_cp_sat_size_threshold=", &RoutingSearchParameters::set_fallback_to_cp_sat_size_threshold)
+    .define_method("first_solution_optimization_period", &RoutingSearchParameters::first_solution_optimization_period)
+    .define_method("first_solution_optimization_period=", &RoutingSearchParameters::set_first_solution_optimization_period)
+    .define_method("guided_local_search_lambda_coefficient", &RoutingSearchParameters::guided_local_search_lambda_coefficient)
+    .define_method("guided_local_search_lambda_coefficient=", &RoutingSearchParameters::set_guided_local_search_lambda_coefficient)
+    .define_method("guided_local_search_penalize_with_vehicle_classes", &RoutingSearchParameters::guided_local_search_penalize_with_vehicle_classes)
+    .define_method("guided_local_search_penalize_with_vehicle_classes=", &RoutingSearchParameters::set_guided_local_search_penalize_with_vehicle_classes)
+    .define_method("guided_local_search_reset_penalties_on_new_best_solution", &RoutingSearchParameters::guided_local_search_reset_penalties_on_new_best_solution)
+    .define_method("guided_local_search_reset_penalties_on_new_best_solution=", &RoutingSearchParameters::set_guided_local_search_reset_penalties_on_new_best_solution)
+    .define_method("heuristic_close_nodes_lns_num_nodes", &RoutingSearchParameters::heuristic_close_nodes_lns_num_nodes)
+    .define_method("heuristic_close_nodes_lns_num_nodes=", &RoutingSearchParameters::set_heuristic_close_nodes_lns_num_nodes)
+    .define_method("heuristic_expensive_chain_lns_num_arcs_to_consider", &RoutingSearchParameters::heuristic_expensive_chain_lns_num_arcs_to_consider)
+    .define_method("heuristic_expensive_chain_lns_num_arcs_to_consider=", &RoutingSearchParameters::set_heuristic_expensive_chain_lns_num_arcs_to_consider)
+    .define_method("log_cost_offset", &RoutingSearchParameters::log_cost_offset)
+    .define_method("log_cost_offset=", &RoutingSearchParameters::set_log_cost_offset)
+    .define_method("log_cost_scaling_factor", &RoutingSearchParameters::log_cost_scaling_factor)
+    .define_method("log_cost_scaling_factor=", &RoutingSearchParameters::set_log_cost_scaling_factor)
+    .define_method("log_search", &RoutingSearchParameters::log_search)
+    .define_method("log_search=", &RoutingSearchParameters::set_log_search)
+    .define_method("log_tag", &RoutingSearchParameters::log_tag)
+    // .define_method("log_tag=", &RoutingSearchParameters::set_log_tag)
+    .define_method("ls_operator_min_neighbors", &RoutingSearchParameters::ls_operator_min_neighbors)
+    .define_method("ls_operator_min_neighbors=", &RoutingSearchParameters::set_ls_operator_min_neighbors)
+    .define_method("ls_operator_neighbors_ratio", &RoutingSearchParameters::ls_operator_neighbors_ratio)
+    .define_method("ls_operator_neighbors_ratio=", &RoutingSearchParameters::set_ls_operator_neighbors_ratio)
+    .define_method("max_swap_active_chain_size", &RoutingSearchParameters::max_swap_active_chain_size)
+    .define_method("max_swap_active_chain_size=", &RoutingSearchParameters::set_max_swap_active_chain_size)
+    .define_method("multi_armed_bandit_compound_operator_exploration_coefficient", &RoutingSearchParameters::multi_armed_bandit_compound_operator_exploration_coefficient)
+    .define_method("multi_armed_bandit_compound_operator_exploration_coefficient=", &RoutingSearchParameters::set_multi_armed_bandit_compound_operator_exploration_coefficient)
+    .define_method("multi_armed_bandit_compound_operator_memory_coefficient", &RoutingSearchParameters::multi_armed_bandit_compound_operator_memory_coefficient)
+    .define_method("multi_armed_bandit_compound_operator_memory_coefficient=", &RoutingSearchParameters::set_multi_armed_bandit_compound_operator_memory_coefficient)
+    .define_method("num_max_local_optima_before_metaheuristic_switch", &RoutingSearchParameters::num_max_local_optima_before_metaheuristic_switch)
+    .define_method("num_max_local_optima_before_metaheuristic_switch=", &RoutingSearchParameters::set_num_max_local_optima_before_metaheuristic_switch)
+    .define_method("number_of_solutions_to_collect", &RoutingSearchParameters::number_of_solutions_to_collect)
+    .define_method("number_of_solutions_to_collect=", &RoutingSearchParameters::set_number_of_solutions_to_collect)
+    .define_method("optimization_step", &RoutingSearchParameters::optimization_step)
+    .define_method("optimization_step=", &RoutingSearchParameters::set_optimization_step)
+    .define_method("relocate_expensive_chain_num_arcs_to_consider", &RoutingSearchParameters::relocate_expensive_chain_num_arcs_to_consider)
+    .define_method("relocate_expensive_chain_num_arcs_to_consider=", &RoutingSearchParameters::set_relocate_expensive_chain_num_arcs_to_consider)
+    .define_method("report_intermediate_cp_sat_solutions", &RoutingSearchParameters::report_intermediate_cp_sat_solutions)
+    .define_method("report_intermediate_cp_sat_solutions=", &RoutingSearchParameters::set_report_intermediate_cp_sat_solutions)
+    .define_method("secondary_ls_time_limit_ratio", &RoutingSearchParameters::secondary_ls_time_limit_ratio)
+    .define_method("secondary_ls_time_limit_ratio=", &RoutingSearchParameters::set_secondary_ls_time_limit_ratio)
+    .define_method("solution_limit", &RoutingSearchParameters::solution_limit)
+    .define_method("solution_limit=", &RoutingSearchParameters::set_solution_limit)
+    .define_method("use_depth_first_search", &RoutingSearchParameters::use_depth_first_search)
+    .define_method("use_depth_first_search=", &RoutingSearchParameters::set_use_depth_first_search)
+    .define_method("use_full_propagation", &RoutingSearchParameters::use_full_propagation)
+    .define_method("use_full_propagation=", &RoutingSearchParameters::set_use_full_propagation)
+    .define_method("use_guided_local_search_penalties_in_local_search_operators", &RoutingSearchParameters::use_guided_local_search_penalties_in_local_search_operators)
+    .define_method("use_guided_local_search_penalties_in_local_search_operators=", &RoutingSearchParameters::set_use_guided_local_search_penalties_in_local_search_operators)
+    .define_method("use_iterated_local_search", &RoutingSearchParameters::use_iterated_local_search)
+    .define_method("use_iterated_local_search=", &RoutingSearchParameters::set_use_iterated_local_search)
+    .define_method("use_multi_armed_bandit_concatenate_operators", &RoutingSearchParameters::use_multi_armed_bandit_concatenate_operators)
+    .define_method("use_multi_armed_bandit_concatenate_operators=", &RoutingSearchParameters::set_use_multi_armed_bandit_concatenate_operators)
+    .define_method("use_unfiltered_first_solution_strategy", &RoutingSearchParameters::use_unfiltered_first_solution_strategy)
+    .define_method("use_unfiltered_first_solution_strategy=", &RoutingSearchParameters::set_use_unfiltered_first_solution_strategy)
     .define_method(
       "first_solution_strategy=",
       [](RoutingSearchParameters& self, Object value) {
@@ -138,7 +238,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,21 +258,12 @@ 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);
       })
-    .define_method(
-      "log_search=",
-      [](RoutingSearchParameters& self, bool value) {
-        self.set_log_search(value);
-      })
-    .define_method(
-      "solution_limit=",
-      [](RoutingSearchParameters& self, int64_t value) {
-        self.set_solution_limit(value);
-      })
+    .define_method("improvement_limit_parameters", &RoutingSearchParameters::mutable_improvement_limit_parameters)
     .define_method(
       "time_limit=",
       [](RoutingSearchParameters& self, int64_t value) {
@@ -192,20 +283,38 @@ 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)
     .define_method("node_to_index", &RoutingIndexManager::NodeToIndex);
 
+
+  Rice::define_class_under<IntervalVarElement>(m, "IntervalVarElement")
+    .define_method("var", &IntervalVarElement::Var)
+    .define_method("start_value", &IntervalVarElement::StartValue)
+    .define_method("duration_value", &IntervalVarElement::DurationValue)
+    .define_method("end_value", &IntervalVarElement::EndValue)
+    .define_method("performed_value", &IntervalVarElement::PerformedValue);
+
+  Rice::define_class_under<Assignment::IntervalContainer>(m, "IntervalContainer")
+    .define_method("size", &Assignment::IntervalContainer::Size)
+    .define_method(
+      "element",
+      [](Assignment::IntervalContainer& self, int index) {
+        return self.Element(index);
+      });
+
   Rice::define_class_under<Assignment>(m, "Assignment")
     .define_method("objective_value", &Assignment::ObjectiveValue)
     .define_method("value", &Assignment::Value)
     .define_method("min", &Assignment::Min)
-    .define_method("max", &Assignment::Max);
+    .define_method("max", &Assignment::Max)
+    .define_method("interval_var_container", &Assignment::IntervalVarContainer);
 
   // not to be confused with operations_research::sat::IntVar
   rb_cIntVar
+    .define_method("name", &operations_research::IntVar::name)
     .define_method("var?", &operations_research::IntVar::IsVar)
     .define_method("value", &operations_research::IntVar::Value)
     .define_method("remove_value", &operations_research::IntVar::RemoveValue)
@@ -223,6 +332,7 @@ void init_routing(Rice::Module& m) {
       });
 
   Rice::define_class_under<operations_research::IntervalVar>(m, "IntervalVar")
+    .define_method("name", &operations_research::IntervalVar::name)
     .define_method("start_min", &operations_research::IntervalVar::StartMin)
     .define_method("start_max", &operations_research::IntervalVar::StartMax)
     .define_method("set_start_min", &operations_research::IntervalVar::SetStartMin)
@@ -250,6 +360,8 @@ void init_routing(Rice::Module& m) {
     .define_method("set_global_span_cost_coefficient", &RoutingDimension::SetGlobalSpanCostCoefficient)
     // alias
     .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient)
+    .define_method("set_slack_cost_coefficient_for_vehicle", &RoutingDimension::SetSlackCostCoefficientForVehicle)
+    .define_method("set_slack_cost_coefficient_for_all_vehicles", &RoutingDimension::SetSlackCostCoefficientForAllVehicles)
     .define_method("set_cumul_var_soft_upper_bound", &RoutingDimension::SetCumulVarSoftUpperBound)
     .define_method("cumul_var_soft_upper_bound?", &RoutingDimension::HasCumulVarSoftUpperBound)
     .define_method("cumul_var_soft_upper_bound", &RoutingDimension::GetCumulVarSoftUpperBound)
@@ -257,7 +369,12 @@ void init_routing(Rice::Module& m) {
     .define_method("set_cumul_var_soft_lower_bound", &RoutingDimension::SetCumulVarSoftLowerBound)
     .define_method("cumul_var_soft_lower_bound?", &RoutingDimension::HasCumulVarSoftLowerBound)
     .define_method("cumul_var_soft_lower_bound", &RoutingDimension::GetCumulVarSoftLowerBound)
-    .define_method("cumul_var_soft_lower_bound_coefficient", &RoutingDimension::GetCumulVarSoftLowerBoundCoefficient);
+    .define_method("cumul_var_soft_lower_bound_coefficient", &RoutingDimension::GetCumulVarSoftLowerBoundCoefficient)
+    .define_method(
+      "set_break_intervals_of_vehicle",
+      [](RoutingDimension& self, std::vector<operations_research::IntervalVar*> breaks, int vehicle, std::vector<int64_t> node_visit_transits) {
+        self.SetBreakIntervalsOfVehicle(breaks, vehicle, node_visit_transits);
+      });
 
   Rice::define_class_under<RoutingDisjunctionIndex>(m, "RoutingDisjunctionIndex");
 
@@ -271,15 +388,24 @@ void init_routing(Rice::Module& m) {
       [](operations_research::Solver& self, Object o) {
         operations_research::Constraint* constraint;
         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();
+          auto left = int_expr(self, o.call("left"));
+          auto right = int_expr(self, o.call("right"));
+          std::string op = o.call("op").to_s().str();
+
           if (op == "==") {
             constraint = self.MakeEquality(left, right);
+          } else if (op == "!=") {
+            constraint = self.MakeNonEquality(left, right);
+          } else if (op == ">") {
+            constraint = self.MakeGreater(left, right);
+          } else if (op == ">=") {
+            constraint = self.MakeGreaterOrEqual(left, right);
+          } else if (op == "<") {
+            constraint = self.MakeLess(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 +414,17 @@ 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(
+      "fixed_duration_interval_var",
+      [](operations_research::Solver& self, int64_t start_min, int64_t start_max, int64_t duration, bool optional, const std::string& name) {
+        return self.MakeFixedDurationIntervalVar(start_min, start_max, duration, optional, 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()));
@@ -302,18 +433,64 @@ void init_routing(Rice::Module& m) {
       });
 
   Rice::define_class_under<ConstraintSolverParameters>(m, "ConstraintSolverParameters")
-    .define_method(
-      "trace_propagation=",
-      [](ConstraintSolverParameters& self, bool value) {
-        self.set_trace_propagation(value);
-      })
-    .define_method(
-      "trace_search=",
-      [](ConstraintSolverParameters& self, bool value) {
-        self.set_trace_search(value);
-      });
+    .define_method("array_split_size", &ConstraintSolverParameters::array_split_size)
+    .define_method("array_split_size=", &ConstraintSolverParameters::set_array_split_size)
+    .define_method("check_solution_period", &ConstraintSolverParameters::check_solution_period)
+    .define_method("check_solution_period=", &ConstraintSolverParameters::set_check_solution_period)
+    .define_method("diffn_use_cumulative", &ConstraintSolverParameters::diffn_use_cumulative)
+    .define_method("diffn_use_cumulative=", &ConstraintSolverParameters::set_diffn_use_cumulative)
+    .define_method("disable_solve", &ConstraintSolverParameters::disable_solve)
+    .define_method("disable_solve=", &ConstraintSolverParameters::set_disable_solve)
+    .define_method("max_edge_finder_size", &ConstraintSolverParameters::max_edge_finder_size)
+    .define_method("max_edge_finder_size=", &ConstraintSolverParameters::set_max_edge_finder_size)
+    .define_method("name_all_variables", &ConstraintSolverParameters::name_all_variables)
+    .define_method("name_all_variables=", &ConstraintSolverParameters::set_name_all_variables)
+    .define_method("name_cast_variables", &ConstraintSolverParameters::name_cast_variables)
+    .define_method("name_cast_variables=", &ConstraintSolverParameters::set_name_cast_variables)
+    .define_method("print_added_constraints", &ConstraintSolverParameters::print_added_constraints)
+    .define_method("print_added_constraints=", &ConstraintSolverParameters::set_print_added_constraints)
+    .define_method("print_local_search_profile", &ConstraintSolverParameters::print_local_search_profile)
+    .define_method("print_local_search_profile=", &ConstraintSolverParameters::set_print_local_search_profile)
+    .define_method("print_model", &ConstraintSolverParameters::print_model)
+    .define_method("print_model=", &ConstraintSolverParameters::set_print_model)
+    .define_method("print_model_stats", &ConstraintSolverParameters::print_model_stats)
+    .define_method("print_model_stats=", &ConstraintSolverParameters::set_print_model_stats)
+    .define_method("profile_file", &ConstraintSolverParameters::profile_file)
+    // .define_method("profile_file=", &ConstraintSolverParameters::set_profile_file)
+    .define_method("profile_local_search", &ConstraintSolverParameters::profile_local_search)
+    .define_method("profile_local_search=", &ConstraintSolverParameters::set_profile_local_search)
+    .define_method("profile_propagation", &ConstraintSolverParameters::profile_propagation)
+    .define_method("profile_propagation=", &ConstraintSolverParameters::set_profile_propagation)
+    .define_method("skip_locally_optimal_paths", &ConstraintSolverParameters::skip_locally_optimal_paths)
+    .define_method("skip_locally_optimal_paths=", &ConstraintSolverParameters::set_skip_locally_optimal_paths)
+    .define_method("store_names", &ConstraintSolverParameters::store_names)
+    .define_method("store_names=", &ConstraintSolverParameters::set_store_names)
+    .define_method("trace_propagation", &ConstraintSolverParameters::trace_propagation)
+    .define_method("trace_propagation=", &ConstraintSolverParameters::set_trace_propagation)
+    .define_method("trace_search", &ConstraintSolverParameters::trace_search)
+    .define_method("trace_search=", &ConstraintSolverParameters::set_trace_search)
+    .define_method("trail_block_size", &ConstraintSolverParameters::trail_block_size)
+    .define_method("trail_block_size=", &ConstraintSolverParameters::set_trail_block_size)
+    .define_method("use_all_possible_disjunctions", &ConstraintSolverParameters::use_all_possible_disjunctions)
+    .define_method("use_all_possible_disjunctions=", &ConstraintSolverParameters::set_use_all_possible_disjunctions)
+    .define_method("use_cumulative_edge_finder", &ConstraintSolverParameters::use_cumulative_edge_finder)
+    .define_method("use_cumulative_edge_finder=", &ConstraintSolverParameters::set_use_cumulative_edge_finder)
+    .define_method("use_cumulative_time_table", &ConstraintSolverParameters::use_cumulative_time_table)
+    .define_method("use_cumulative_time_table=", &ConstraintSolverParameters::set_use_cumulative_time_table)
+    .define_method("use_cumulative_time_table_sync", &ConstraintSolverParameters::use_cumulative_time_table_sync)
+    .define_method("use_cumulative_time_table_sync=", &ConstraintSolverParameters::set_use_cumulative_time_table_sync)
+    .define_method("use_element_rmq", &ConstraintSolverParameters::use_element_rmq)
+    .define_method("use_element_rmq=", &ConstraintSolverParameters::set_use_element_rmq)
+    .define_method("use_sequence_high_demand_tasks", &ConstraintSolverParameters::use_sequence_high_demand_tasks)
+    .define_method("use_sequence_high_demand_tasks=", &ConstraintSolverParameters::set_use_sequence_high_demand_tasks)
+    .define_method("use_small_table", &ConstraintSolverParameters::use_small_table)
+    .define_method("use_small_table=", &ConstraintSolverParameters::set_use_small_table);
 
   Rice::define_class_under<RoutingModelParameters>(m, "RoutingModelParameters")
+    .define_method("reduce_vehicle_cost_model", &RoutingModelParameters::reduce_vehicle_cost_model)
+    .define_method("reduce_vehicle_cost_model=", &RoutingModelParameters::set_reduce_vehicle_cost_model)
+    .define_method("max_callback_cache_size", &RoutingModelParameters::max_callback_cache_size)
+    .define_method("max_callback_cache_size=", &RoutingModelParameters::set_max_callback_cache_size)
     .define_method(
       "solver_parameters",
       [](RoutingModelParameters& self) {
@@ -332,13 +509,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 +524,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 +563,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 +607,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,17 +644,31 @@ 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)
     .define_method("write_assignment", &RoutingModel::WriteAssignment)
     .define_method("read_assignment", &RoutingModel::ReadAssignment)
     .define_method("restore_assignment", &RoutingModel::RestoreAssignment)
-    .define_method("read_assignment_from_routes", &RoutingModel::ReadAssignmentFromRoutes)
+    .define_method(
+      "_read_assignment_from_routes",
+      [](RoutingModel& self, const std::vector<std::vector<int64_t>>& routes, bool ignore_inactive_indices, bool release_gvl) {
+        if (release_gvl) {
+          return Rice::detail::no_gvl([&]() {
+            return self.ReadAssignmentFromRoutes(routes, ignore_inactive_indices);
+          });
+        } else {
+          return self.ReadAssignmentFromRoutes(routes, ignore_inactive_indices);
+        }
+      })
     .define_method("routes_to_assignment", &RoutingModel::RoutesToAssignment)
     .define_method("assignment_to_routes", &RoutingModel::AssignmentToRoutes)
     .define_method("compact_assignment", &RoutingModel::CompactAssignment)

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,27 @@ 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 read_assignment_from_routes(routes, ignore_inactive_indices)
+      _read_assignment_from_routes(routes, ignore_inactive_indices, !@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