From 600aad7748ac4c91249a70492079895113d015ee Mon Sep 17 00:00:00 2001 From: Will Bryant Date: Mon, 14 Sep 2026 10:29:45 +1200 Subject: [PATCH 01/13] Add RoutingDimension#set_slack_cost_coefficient_for_vehicle and #set_slack_cost_coefficient_for_all_vehicles (#89) --- ext/or-tools/routing.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index 88ff5bc..f98eeb1 100644 --- a/ext/or-tools/routing.cpp +++ b/ext/or-tools/routing.cpp @@ -250,6 +250,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) From 729d1553bd406cc8ffeed9042e1db8cf718028ef Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Mon, 14 Sep 2026 09:46:13 -0700 Subject: [PATCH 02/13] Added support for breaks for routing - resolves #88 Co-authored-by: Mark Spit --- CHANGELOG.md | 4 ++++ ext/or-tools/routing.cpp | 33 +++++++++++++++++++++++++++++++-- 2 files changed, 35 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 81d9df6..8760b7c 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,7 @@ +## 0.18.1 (unreleased) + +- Added support for breaks for routing + ## 0.18.0 (2026-07-06) - Added support for releasing GVL diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index f98eeb1..c7b23e7 100644 --- a/ext/or-tools/routing.cpp +++ b/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; @@ -198,11 +199,28 @@ void init_routing(Rice::Module& m) { .define_method("index_to_node", &RoutingIndexManager::IndexToNode) .define_method("node_to_index", &RoutingIndexManager::NodeToIndex); + + Rice::define_class_under(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(m, "IntervalContainer") + .define_method("size", &Assignment::IntervalContainer::Size) + .define_method( + "element", + [](Assignment::IntervalContainer& self, int index) { + return self.Element(index); + }); + Rice::define_class_under(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 @@ -223,6 +241,7 @@ void init_routing(Rice::Module& m) { }); Rice::define_class_under(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) @@ -259,7 +278,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 breaks, int vehicle, std::vector node_visit_transits) { + self.SetBreakIntervalsOfVehicle(breaks, vehicle, node_visit_transits); + }); Rice::define_class_under(m, "RoutingDisjunctionIndex"); @@ -293,6 +317,11 @@ void init_routing(Rice::Module& m) { [](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, const std::vector& demands, int64_t capacity, const std::string& name) { From 135ac4e89132d850428e1418642aafa34a6f4a95 Mon Sep 17 00:00:00 2001 From: Will Bryant Date: Tue, 15 Sep 2026 15:24:24 +1200 Subject: [PATCH 03/13] Implement RoutingIntVar#name to fix #inspect NameError (#90) --- ext/or-tools/routing.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index c7b23e7..3bb2429 100644 --- a/ext/or-tools/routing.cpp +++ b/ext/or-tools/routing.cpp @@ -224,6 +224,7 @@ void init_routing(Rice::Module& m) { // 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) From 44eb655583359d02aa18cb2e9db1ea78637f6682 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Wed, 16 Sep 2026 13:04:40 -0700 Subject: [PATCH 04/13] Added support for more constraints for routing - #92 and #93 [skip ci] Co-authored-by: Will Bryant --- ext/or-tools/routing.cpp | 45 ++++++++++++++++++++++++++++++++++++++-- 1 file changed, 43 insertions(+), 2 deletions(-) diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index 3bb2429..bf6ea7b 100644 --- a/ext/or-tools/routing.cpp +++ b/ext/or-tools/routing.cpp @@ -97,6 +97,38 @@ 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().convert(v); +} + +operations_research::IntExpr* int_expr(operations_research::Solver& solver, Object o) { + Object utils = Rice::define_module("ORTools").const_get("Utils"); + Rice::Hash rb_coeffs = utils.call("index_expression", o); + + std::vector vars; + std::vector 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().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(m, "RoutingSearchParameters"); auto rb_cIntVar = Rice::define_class_under(m, "RoutingIntVar"); @@ -298,11 +330,20 @@ 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().convert(o.call("left"))); - operations_research::IntExpr* right(Rice::detail::From_Ruby().convert(o.call("right"))); + 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 { From 64c28e8d85ffbfc554f5672bc5938467da282fb6 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Wed, 16 Sep 2026 13:26:01 -0700 Subject: [PATCH 05/13] Updated style [skip ci] --- ext/or-tools/constraint.cpp | 5 +++-- ext/or-tools/routing.cpp | 3 ++- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/ext/or-tools/constraint.cpp b/ext/or-tools/constraint.cpp index 7d18b22..312c70c 100644 --- a/ext/or-tools/constraint.cpp +++ b/ext/or-tools/constraint.cpp @@ -29,6 +29,7 @@ using operations_research::sat::TableConstraint; using Rice::Array; using Rice::Class; +using Rice::Hash; using Rice::Object; using Rice::String; using Rice::Symbol; @@ -54,8 +55,8 @@ namespace Rice::detail { LinearExpr convert(VALUE v) { LinearExpr expr; - Rice::Object utils = Rice::define_module("ORTools").const_get("Utils"); - Rice::Hash coeffs = utils.call("index_expression", Object(v)); + Object utils = Rice::define_module("ORTools").const_get("Utils"); + Hash coeffs = utils.call("index_expression", Object(v)); for (const auto& entry : coeffs) { Object var = entry.key; diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index bf6ea7b..efa5da3 100644 --- a/ext/or-tools/routing.cpp +++ b/ext/or-tools/routing.cpp @@ -23,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; @@ -106,7 +107,7 @@ int64_t int64_strict(VALUE v) { operations_research::IntExpr* int_expr(operations_research::Solver& solver, Object o) { Object utils = Rice::define_module("ORTools").const_get("Utils"); - Rice::Hash rb_coeffs = utils.call("index_expression", o); + Hash rb_coeffs = utils.call("index_expression", o); std::vector vars; std::vector coeffs; From 437b3375afefbb04a9b787a12803d2017288fe1a Mon Sep 17 00:00:00 2001 From: edolix Date: Thu, 1 Oct 2026 17:30:32 +0200 Subject: [PATCH 06/13] add log_search_progress, max_deterministic_time and fix_variables_to_their_hinted_value --- ext/or-tools/constraint.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/ext/or-tools/constraint.cpp b/ext/or-tools/constraint.cpp index 312c70c..933bff1 100644 --- a/ext/or-tools/constraint.cpp +++ b/ext/or-tools/constraint.cpp @@ -141,8 +141,14 @@ void init_constraint(Rice::Module& m) { .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("fix_variables_to_their_hinted_value", &SatParameters::fix_variables_to_their_hinted_value) + .define_method("fix_variables_to_their_hinted_value=", &SatParameters::set_fix_variables_to_their_hinted_value) .define_method("linearization_level", &SatParameters::linearization_level) .define_method("linearization_level=", &SatParameters::set_linearization_level) + .define_method("log_search_progress", &SatParameters::log_search_progress) + .define_method("log_search_progress=", &SatParameters::set_log_search_progress) + .define_method("max_deterministic_time", &SatParameters::max_deterministic_time) + .define_method("max_deterministic_time=", &SatParameters::set_max_deterministic_time) .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) From 7b3d148026049b75b31a421aefe4902e508120dd Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Thu, 1 Oct 2026 15:09:49 -0700 Subject: [PATCH 07/13] Added tests for parameters [skip ci] --- test/constraint_test.rb | 41 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 41 insertions(+) diff --git a/test/constraint_test.rb b/test/constraint_test.rb index f419898..bb598d9 100644 --- a/test/constraint_test.rb +++ b/test/constraint_test.rb @@ -318,4 +318,45 @@ def test_domain_from_values assert_equal 1, domain.min assert_equal 3, domain.max end + + def test_parameters + solver = ORTools::CpSolver.new + parameters = solver.parameters + + assert_equal true, parameters.cp_model_presolve + parameters.cp_model_presolve = false + assert_equal false, parameters.cp_model_presolve + + assert_equal false, parameters.enumerate_all_solutions + parameters.enumerate_all_solutions = true + assert_equal true, parameters.enumerate_all_solutions + + assert_equal false, parameters.fix_variables_to_their_hinted_value + parameters.fix_variables_to_their_hinted_value = true + assert_equal true, parameters.fix_variables_to_their_hinted_value + + assert_equal 1, parameters.linearization_level + parameters.linearization_level = 0 + assert_equal 0, parameters.linearization_level + + assert_equal false, parameters.log_search_progress + parameters.log_search_progress = true + assert_equal true, parameters.log_search_progress + + assert_equal Float::INFINITY, parameters.max_deterministic_time + parameters.max_deterministic_time = 1 + assert_equal 1, parameters.max_deterministic_time + + assert_equal Float::INFINITY, parameters.max_time_in_seconds + parameters.max_time_in_seconds = 1 + assert_equal 1, parameters.max_time_in_seconds + + assert_equal 0, parameters.num_workers + parameters.num_workers = 1 + assert_equal 1, parameters.num_workers + + assert_equal 1, parameters.random_seed + parameters.random_seed = 2 + assert_equal 2, parameters.random_seed + end end From 4c98f82ce317bd4ea6aafc267df39da3d274aa51 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Thu, 1 Oct 2026 15:23:47 -0700 Subject: [PATCH 08/13] Added more methods to SatParameters [skip ci] --- CHANGELOG.md | 1 + ext/or-tools/constraint.cpp | 18 +++++++++++++++++- test/constraint_test.rb | 12 ++++++++++++ 3 files changed, 30 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8760b7c..d3d0a06 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ ## 0.18.1 (unreleased) - Added support for breaks for routing +- Added more methods to `SatParameters` ## 0.18.0 (2026-07-06) diff --git a/ext/or-tools/constraint.cpp b/ext/or-tools/constraint.cpp index 933bff1..8c61ca7 100644 --- a/ext/or-tools/constraint.cpp +++ b/ext/or-tools/constraint.cpp @@ -137,12 +137,16 @@ void init_constraint(Rice::Module& m) { Rice::define_class_under(m, "SatParameters") .define_constructor(Rice::Constructor()) + .define_method("also_bump_variables_in_conflict_reasons", &SatParameters::also_bump_variables_in_conflict_reasons) + .define_method("also_bump_variables_in_conflict_reasons=", &SatParameters::set_also_bump_variables_in_conflict_reasons) .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("fix_variables_to_their_hinted_value", &SatParameters::fix_variables_to_their_hinted_value) .define_method("fix_variables_to_their_hinted_value=", &SatParameters::set_fix_variables_to_their_hinted_value) + .define_method("initial_variables_activity", &SatParameters::initial_variables_activity) + .define_method("initial_variables_activity=", &SatParameters::set_initial_variables_activity) .define_method("linearization_level", &SatParameters::linearization_level) .define_method("linearization_level=", &SatParameters::set_linearization_level) .define_method("log_search_progress", &SatParameters::log_search_progress) @@ -151,10 +155,22 @@ void init_constraint(Rice::Module& m) { .define_method("max_deterministic_time=", &SatParameters::set_max_deterministic_time) .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("polarity_exploit_ls_hints", &SatParameters::polarity_exploit_ls_hints) + .define_method("polarity_exploit_ls_hints=", &SatParameters::set_polarity_exploit_ls_hints) + .define_method("polarity_rephase_increment", &SatParameters::polarity_rephase_increment) + .define_method("polarity_rephase_increment=", &SatParameters::set_polarity_rephase_increment) .define_method("num_workers", &SatParameters::num_workers) .define_method("num_workers=", &SatParameters::set_num_workers) + .define_method("random_branches_ratio", &SatParameters::random_branches_ratio) + .define_method("random_branches_ratio=", &SatParameters::set_random_branches_ratio) + .define_method("random_polarity_ratio", &SatParameters::random_polarity_ratio) + .define_method("random_polarity_ratio=", &SatParameters::set_random_polarity_ratio) .define_method("random_seed", &SatParameters::random_seed) - .define_method("random_seed=", &SatParameters::set_random_seed); + .define_method("random_seed=", &SatParameters::set_random_seed) + .define_method("use_erwa_heuristic", &SatParameters::use_erwa_heuristic) + .define_method("use_erwa_heuristic=", &SatParameters::set_use_erwa_heuristic) + .define_method("use_phase_saving", &SatParameters::use_phase_saving) + .define_method("use_phase_saving=", &SatParameters::set_use_phase_saving); Rice::define_class_under(m, "CpModel") .define_constructor(Rice::Constructor()) diff --git a/test/constraint_test.rb b/test/constraint_test.rb index bb598d9..fdad09d 100644 --- a/test/constraint_test.rb +++ b/test/constraint_test.rb @@ -355,8 +355,20 @@ def test_parameters parameters.num_workers = 1 assert_equal 1, parameters.num_workers + assert_equal false, parameters.polarity_exploit_ls_hints + parameters.polarity_exploit_ls_hints = true + assert_equal true, parameters.polarity_exploit_ls_hints + + assert_equal 1000, parameters.polarity_rephase_increment + parameters.polarity_rephase_increment = 1001 + assert_equal 1001, parameters.polarity_rephase_increment + assert_equal 1, parameters.random_seed parameters.random_seed = 2 assert_equal 2, parameters.random_seed + + assert_equal true, parameters.use_phase_saving + parameters.use_phase_saving = false + assert_equal false, parameters.use_phase_saving end end From ee8e5ace083328a222ce0ac9d93aa23ae76e6f33 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Thu, 1 Oct 2026 15:41:17 -0700 Subject: [PATCH 09/13] Added more methods to SatParameters [skip ci] --- ext/or-tools/constraint.cpp | 546 +++++++++++++++++++++++++++++++++++- 1 file changed, 543 insertions(+), 3 deletions(-) diff --git a/ext/or-tools/constraint.cpp b/ext/or-tools/constraint.cpp index 8c61ca7..74ae9f6 100644 --- a/ext/or-tools/constraint.cpp +++ b/ext/or-tools/constraint.cpp @@ -137,40 +137,580 @@ void init_constraint(Rice::Module& m) { Rice::define_class_under(m, "SatParameters") .define_constructor(Rice::Constructor()) + .define_method("absolute_gap_limit", &SatParameters::absolute_gap_limit) + .define_method("absolute_gap_limit=", &SatParameters::set_absolute_gap_limit) + .define_method("add_cg_cuts", &SatParameters::add_cg_cuts) + .define_method("add_cg_cuts=", &SatParameters::set_add_cg_cuts) + .define_method("add_clique_cuts", &SatParameters::add_clique_cuts) + .define_method("add_clique_cuts=", &SatParameters::set_add_clique_cuts) + .define_method("add_lin_max_cuts", &SatParameters::add_lin_max_cuts) + .define_method("add_lin_max_cuts=", &SatParameters::set_add_lin_max_cuts) + .define_method("add_lp_constraints_lazily", &SatParameters::add_lp_constraints_lazily) + .define_method("add_lp_constraints_lazily=", &SatParameters::set_add_lp_constraints_lazily) + .define_method("add_mir_cuts", &SatParameters::add_mir_cuts) + .define_method("add_mir_cuts=", &SatParameters::set_add_mir_cuts) + .define_method("add_objective_cut", &SatParameters::add_objective_cut) + .define_method("add_objective_cut=", &SatParameters::set_add_objective_cut) + .define_method("add_rlt_cuts", &SatParameters::add_rlt_cuts) + .define_method("add_rlt_cuts=", &SatParameters::set_add_rlt_cuts) + .define_method("add_zero_half_cuts", &SatParameters::add_zero_half_cuts) + .define_method("add_zero_half_cuts=", &SatParameters::set_add_zero_half_cuts) .define_method("also_bump_variables_in_conflict_reasons", &SatParameters::also_bump_variables_in_conflict_reasons) .define_method("also_bump_variables_in_conflict_reasons=", &SatParameters::set_also_bump_variables_in_conflict_reasons) + .define_method("alternative_pool_size", &SatParameters::alternative_pool_size) + .define_method("alternative_pool_size=", &SatParameters::set_alternative_pool_size) + .define_method("at_most_one_max_expansion_size", &SatParameters::at_most_one_max_expansion_size) + .define_method("at_most_one_max_expansion_size=", &SatParameters::set_at_most_one_max_expansion_size) + .define_method("auto_detect_greater_than_at_least_one_of", &SatParameters::auto_detect_greater_than_at_least_one_of) + .define_method("auto_detect_greater_than_at_least_one_of=", &SatParameters::set_auto_detect_greater_than_at_least_one_of) + .define_method("binary_search_num_conflicts", &SatParameters::binary_search_num_conflicts) + .define_method("binary_search_num_conflicts=", &SatParameters::set_binary_search_num_conflicts) + .define_method("blocking_restart_multiplier", &SatParameters::blocking_restart_multiplier) + .define_method("blocking_restart_multiplier=", &SatParameters::set_blocking_restart_multiplier) + .define_method("blocking_restart_window_size", &SatParameters::blocking_restart_window_size) + .define_method("blocking_restart_window_size=", &SatParameters::set_blocking_restart_window_size) + .define_method("boolean_encoding_level", &SatParameters::boolean_encoding_level) + .define_method("boolean_encoding_level=", &SatParameters::set_boolean_encoding_level) + .define_method("catch_sigint_signal", &SatParameters::catch_sigint_signal) + .define_method("catch_sigint_signal=", &SatParameters::set_catch_sigint_signal) + .define_method("check_drat_proof", &SatParameters::check_drat_proof) + .define_method("check_drat_proof=", &SatParameters::set_check_drat_proof) + .define_method("check_lrat_proof", &SatParameters::check_lrat_proof) + .define_method("check_lrat_proof=", &SatParameters::set_check_lrat_proof) + .define_method("check_merged_lrat_proof", &SatParameters::check_merged_lrat_proof) + .define_method("check_merged_lrat_proof=", &SatParameters::set_check_merged_lrat_proof) + .define_method("chronological_backtrack_min_conflicts", &SatParameters::chronological_backtrack_min_conflicts) + .define_method("chronological_backtrack_min_conflicts=", &SatParameters::set_chronological_backtrack_min_conflicts) + .define_method("clause_activity_decay", &SatParameters::clause_activity_decay) + .define_method("clause_activity_decay=", &SatParameters::set_clause_activity_decay) + .define_method("clause_cleanup_lbd_bound", &SatParameters::clause_cleanup_lbd_bound) + .define_method("clause_cleanup_lbd_bound=", &SatParameters::set_clause_cleanup_lbd_bound) + .define_method("clause_cleanup_lbd_tier1", &SatParameters::clause_cleanup_lbd_tier1) + .define_method("clause_cleanup_lbd_tier1=", &SatParameters::set_clause_cleanup_lbd_tier1) + .define_method("clause_cleanup_lbd_tier2", &SatParameters::clause_cleanup_lbd_tier2) + .define_method("clause_cleanup_lbd_tier2=", &SatParameters::set_clause_cleanup_lbd_tier2) + .define_method("clause_cleanup_period", &SatParameters::clause_cleanup_period) + .define_method("clause_cleanup_period=", &SatParameters::set_clause_cleanup_period) + .define_method("clause_cleanup_period_increment", &SatParameters::clause_cleanup_period_increment) + .define_method("clause_cleanup_period_increment=", &SatParameters::set_clause_cleanup_period_increment) + .define_method("clause_cleanup_ratio", &SatParameters::clause_cleanup_ratio) + .define_method("clause_cleanup_ratio=", &SatParameters::set_clause_cleanup_ratio) + .define_method("clause_cleanup_target", &SatParameters::clause_cleanup_target) + .define_method("clause_cleanup_target=", &SatParameters::set_clause_cleanup_target) + .define_method("convert_intervals", &SatParameters::convert_intervals) + .define_method("convert_intervals=", &SatParameters::set_convert_intervals) + .define_method("core_minimization_level", &SatParameters::core_minimization_level) + .define_method("core_minimization_level=", &SatParameters::set_core_minimization_level) + .define_method("count_assumption_levels_in_lbd", &SatParameters::count_assumption_levels_in_lbd) + .define_method("count_assumption_levels_in_lbd=", &SatParameters::set_count_assumption_levels_in_lbd) + .define_method("cover_optimization", &SatParameters::cover_optimization) + .define_method("cover_optimization=", &SatParameters::set_cover_optimization) .define_method("cp_model_presolve", &SatParameters::cp_model_presolve) .define_method("cp_model_presolve=", &SatParameters::set_cp_model_presolve) + .define_method("cp_model_probing_level", &SatParameters::cp_model_probing_level) + .define_method("cp_model_probing_level=", &SatParameters::set_cp_model_probing_level) + .define_method("cp_model_use_sat_presolve", &SatParameters::cp_model_use_sat_presolve) + .define_method("cp_model_use_sat_presolve=", &SatParameters::set_cp_model_use_sat_presolve) + .define_method("create_1uip_boolean_during_icr", &SatParameters::create_1uip_boolean_during_icr) + .define_method("create_1uip_boolean_during_icr=", &SatParameters::set_create_1uip_boolean_during_icr) + .define_method("cut_active_count_decay", &SatParameters::cut_active_count_decay) + .define_method("cut_active_count_decay=", &SatParameters::set_cut_active_count_decay) + .define_method("cut_cleanup_target", &SatParameters::cut_cleanup_target) + .define_method("cut_cleanup_target=", &SatParameters::set_cut_cleanup_target) + .define_method("cut_level", &SatParameters::cut_level) + .define_method("cut_level=", &SatParameters::set_cut_level) + .define_method("cut_max_active_count_value", &SatParameters::cut_max_active_count_value) + .define_method("cut_max_active_count_value=", &SatParameters::set_cut_max_active_count_value) + .define_method("debug_crash_if_lrat_check_fails", &SatParameters::debug_crash_if_lrat_check_fails) + .define_method("debug_crash_if_lrat_check_fails=", &SatParameters::set_debug_crash_if_lrat_check_fails) + .define_method("debug_crash_if_presolve_breaks_hint", &SatParameters::debug_crash_if_presolve_breaks_hint) + .define_method("debug_crash_if_presolve_breaks_hint=", &SatParameters::set_debug_crash_if_presolve_breaks_hint) + .define_method("debug_crash_on_bad_hint", &SatParameters::debug_crash_on_bad_hint) + .define_method("debug_crash_on_bad_hint=", &SatParameters::set_debug_crash_on_bad_hint) + .define_method("debug_max_num_presolve_operations", &SatParameters::debug_max_num_presolve_operations) + .define_method("debug_max_num_presolve_operations=", &SatParameters::set_debug_max_num_presolve_operations) + .define_method("debug_postsolve_with_full_solver", &SatParameters::debug_postsolve_with_full_solver) + .define_method("debug_postsolve_with_full_solver=", &SatParameters::set_debug_postsolve_with_full_solver) + .define_method("decision_subsumption_during_conflict_analysis", &SatParameters::decision_subsumption_during_conflict_analysis) + .define_method("decision_subsumption_during_conflict_analysis=", &SatParameters::set_decision_subsumption_during_conflict_analysis) + .define_method("default_restart_algorithms", &SatParameters::default_restart_algorithms) + // .define_method("default_restart_algorithms=", &SatParameters::set_default_restart_algorithms) + .define_method("detect_linearized_product", &SatParameters::detect_linearized_product) + .define_method("detect_linearized_product=", &SatParameters::set_detect_linearized_product) + .define_method("detect_table_with_cost", &SatParameters::detect_table_with_cost) + .define_method("detect_table_with_cost=", &SatParameters::set_detect_table_with_cost) + .define_method("disable_constraint_expansion", &SatParameters::disable_constraint_expansion) + .define_method("disable_constraint_expansion=", &SatParameters::set_disable_constraint_expansion) + .define_method("diversify_lns_params", &SatParameters::diversify_lns_params) + .define_method("diversify_lns_params=", &SatParameters::set_diversify_lns_params) + .define_method("eagerly_subsume_last_n_conflicts", &SatParameters::eagerly_subsume_last_n_conflicts) + .define_method("eagerly_subsume_last_n_conflicts=", &SatParameters::set_eagerly_subsume_last_n_conflicts) + .define_method("encode_complex_linear_constraint_with_integer", &SatParameters::encode_complex_linear_constraint_with_integer) + .define_method("encode_complex_linear_constraint_with_integer=", &SatParameters::set_encode_complex_linear_constraint_with_integer) + .define_method("encode_cumulative_as_reservoir", &SatParameters::encode_cumulative_as_reservoir) + .define_method("encode_cumulative_as_reservoir=", &SatParameters::set_encode_cumulative_as_reservoir) .define_method("enumerate_all_solutions", &SatParameters::enumerate_all_solutions) .define_method("enumerate_all_solutions=", &SatParameters::set_enumerate_all_solutions) + .define_method("expand_alldiff_constraints", &SatParameters::expand_alldiff_constraints) + .define_method("expand_alldiff_constraints=", &SatParameters::set_expand_alldiff_constraints) + .define_method("expand_reservoir_constraints", &SatParameters::expand_reservoir_constraints) + .define_method("expand_reservoir_constraints=", &SatParameters::set_expand_reservoir_constraints) + .define_method("expand_reservoir_using_circuit", &SatParameters::expand_reservoir_using_circuit) + .define_method("expand_reservoir_using_circuit=", &SatParameters::set_expand_reservoir_using_circuit) + .define_method("exploit_all_lp_solution", &SatParameters::exploit_all_lp_solution) + .define_method("exploit_all_lp_solution=", &SatParameters::set_exploit_all_lp_solution) + .define_method("exploit_all_precedences", &SatParameters::exploit_all_precedences) + .define_method("exploit_all_precedences=", &SatParameters::set_exploit_all_precedences) + .define_method("exploit_best_solution", &SatParameters::exploit_best_solution) + .define_method("exploit_best_solution=", &SatParameters::set_exploit_best_solution) + .define_method("exploit_integer_lp_solution", &SatParameters::exploit_integer_lp_solution) + .define_method("exploit_integer_lp_solution=", &SatParameters::set_exploit_integer_lp_solution) + .define_method("exploit_objective", &SatParameters::exploit_objective) + .define_method("exploit_objective=", &SatParameters::set_exploit_objective) + .define_method("exploit_relaxation_solution", &SatParameters::exploit_relaxation_solution) + .define_method("exploit_relaxation_solution=", &SatParameters::set_exploit_relaxation_solution) + .define_method("extra_subsumption_during_conflict_analysis", &SatParameters::extra_subsumption_during_conflict_analysis) + .define_method("extra_subsumption_during_conflict_analysis=", &SatParameters::set_extra_subsumption_during_conflict_analysis) + .define_method("feasibility_jump_batch_dtime", &SatParameters::feasibility_jump_batch_dtime) + .define_method("feasibility_jump_batch_dtime=", &SatParameters::set_feasibility_jump_batch_dtime) + .define_method("feasibility_jump_decay", &SatParameters::feasibility_jump_decay) + .define_method("feasibility_jump_decay=", &SatParameters::set_feasibility_jump_decay) + .define_method("feasibility_jump_enable_restarts", &SatParameters::feasibility_jump_enable_restarts) + .define_method("feasibility_jump_enable_restarts=", &SatParameters::set_feasibility_jump_enable_restarts) + .define_method("feasibility_jump_linearization_level", &SatParameters::feasibility_jump_linearization_level) + .define_method("feasibility_jump_linearization_level=", &SatParameters::set_feasibility_jump_linearization_level) + .define_method("feasibility_jump_max_expanded_constraint_size", &SatParameters::feasibility_jump_max_expanded_constraint_size) + .define_method("feasibility_jump_max_expanded_constraint_size=", &SatParameters::set_feasibility_jump_max_expanded_constraint_size) + .define_method("feasibility_jump_restart_factor", &SatParameters::feasibility_jump_restart_factor) + .define_method("feasibility_jump_restart_factor=", &SatParameters::set_feasibility_jump_restart_factor) + .define_method("feasibility_jump_var_perburbation_range_ratio", &SatParameters::feasibility_jump_var_perburbation_range_ratio) + .define_method("feasibility_jump_var_perburbation_range_ratio=", &SatParameters::set_feasibility_jump_var_perburbation_range_ratio) + .define_method("feasibility_jump_var_randomization_probability", &SatParameters::feasibility_jump_var_randomization_probability) + .define_method("feasibility_jump_var_randomization_probability=", &SatParameters::set_feasibility_jump_var_randomization_probability) + .define_method("fill_additional_solutions_in_response", &SatParameters::fill_additional_solutions_in_response) + .define_method("fill_additional_solutions_in_response=", &SatParameters::set_fill_additional_solutions_in_response) + .define_method("fill_tightened_domains_in_response", &SatParameters::fill_tightened_domains_in_response) + .define_method("fill_tightened_domains_in_response=", &SatParameters::set_fill_tightened_domains_in_response) + .define_method("filter_sat_postsolve_clauses", &SatParameters::filter_sat_postsolve_clauses) + .define_method("filter_sat_postsolve_clauses=", &SatParameters::set_filter_sat_postsolve_clauses) + .define_method("find_big_linear_overlap", &SatParameters::find_big_linear_overlap) + .define_method("find_big_linear_overlap=", &SatParameters::set_find_big_linear_overlap) + .define_method("find_clauses_that_are_exactly_one", &SatParameters::find_clauses_that_are_exactly_one) + .define_method("find_clauses_that_are_exactly_one=", &SatParameters::set_find_clauses_that_are_exactly_one) + .define_method("find_multiple_cores", &SatParameters::find_multiple_cores) + .define_method("find_multiple_cores=", &SatParameters::set_find_multiple_cores) .define_method("fix_variables_to_their_hinted_value", &SatParameters::fix_variables_to_their_hinted_value) .define_method("fix_variables_to_their_hinted_value=", &SatParameters::set_fix_variables_to_their_hinted_value) + .define_method("glucose_decay_increment", &SatParameters::glucose_decay_increment) + .define_method("glucose_decay_increment=", &SatParameters::set_glucose_decay_increment) + .define_method("glucose_decay_increment_period", &SatParameters::glucose_decay_increment_period) + .define_method("glucose_decay_increment_period=", &SatParameters::set_glucose_decay_increment_period) + .define_method("glucose_max_decay", &SatParameters::glucose_max_decay) + .define_method("glucose_max_decay=", &SatParameters::set_glucose_max_decay) + .define_method("hint_conflict_limit", &SatParameters::hint_conflict_limit) + .define_method("hint_conflict_limit=", &SatParameters::set_hint_conflict_limit) + .define_method("ignore_names", &SatParameters::ignore_names) + .define_method("ignore_names=", &SatParameters::set_ignore_names) + .define_method("infer_all_diffs", &SatParameters::infer_all_diffs) + .define_method("infer_all_diffs=", &SatParameters::set_infer_all_diffs) .define_method("initial_variables_activity", &SatParameters::initial_variables_activity) .define_method("initial_variables_activity=", &SatParameters::set_initial_variables_activity) + .define_method("inprocessing_dtime_ratio", &SatParameters::inprocessing_dtime_ratio) + .define_method("inprocessing_dtime_ratio=", &SatParameters::set_inprocessing_dtime_ratio) + .define_method("inprocessing_minimization_dtime", &SatParameters::inprocessing_minimization_dtime) + .define_method("inprocessing_minimization_dtime=", &SatParameters::set_inprocessing_minimization_dtime) + .define_method("inprocessing_minimization_use_all_orderings", &SatParameters::inprocessing_minimization_use_all_orderings) + .define_method("inprocessing_minimization_use_all_orderings=", &SatParameters::set_inprocessing_minimization_use_all_orderings) + .define_method("inprocessing_minimization_use_conflict_analysis", &SatParameters::inprocessing_minimization_use_conflict_analysis) + .define_method("inprocessing_minimization_use_conflict_analysis=", &SatParameters::set_inprocessing_minimization_use_conflict_analysis) + .define_method("inprocessing_probing_dtime", &SatParameters::inprocessing_probing_dtime) + .define_method("inprocessing_probing_dtime=", &SatParameters::set_inprocessing_probing_dtime) + .define_method("inprocessing_use_congruence_closure", &SatParameters::inprocessing_use_congruence_closure) + .define_method("inprocessing_use_congruence_closure=", &SatParameters::set_inprocessing_use_congruence_closure) + .define_method("inprocessing_use_sat_sweeping", &SatParameters::inprocessing_use_sat_sweeping) + .define_method("inprocessing_use_sat_sweeping=", &SatParameters::set_inprocessing_use_sat_sweeping) + .define_method("instantiate_all_variables", &SatParameters::instantiate_all_variables) + .define_method("instantiate_all_variables=", &SatParameters::set_instantiate_all_variables) + .define_method("interleave_batch_size", &SatParameters::interleave_batch_size) + .define_method("interleave_batch_size=", &SatParameters::set_interleave_batch_size) + .define_method("interleave_search", &SatParameters::interleave_search) + .define_method("interleave_search=", &SatParameters::set_interleave_search) + .define_method("keep_all_feasible_solutions_in_presolve", &SatParameters::keep_all_feasible_solutions_in_presolve) + .define_method("keep_all_feasible_solutions_in_presolve=", &SatParameters::set_keep_all_feasible_solutions_in_presolve) + .define_method("keep_symmetry_in_presolve", &SatParameters::keep_symmetry_in_presolve) + .define_method("keep_symmetry_in_presolve=", &SatParameters::set_keep_symmetry_in_presolve) + .define_method("lb_relax_num_workers_threshold", &SatParameters::lb_relax_num_workers_threshold) + .define_method("lb_relax_num_workers_threshold=", &SatParameters::set_lb_relax_num_workers_threshold) + .define_method("linear_split_size", &SatParameters::linear_split_size) + .define_method("linear_split_size=", &SatParameters::set_linear_split_size) .define_method("linearization_level", &SatParameters::linearization_level) .define_method("linearization_level=", &SatParameters::set_linearization_level) + .define_method("lns_initial_deterministic_limit", &SatParameters::lns_initial_deterministic_limit) + .define_method("lns_initial_deterministic_limit=", &SatParameters::set_lns_initial_deterministic_limit) + .define_method("lns_initial_difficulty", &SatParameters::lns_initial_difficulty) + .define_method("lns_initial_difficulty=", &SatParameters::set_lns_initial_difficulty) + .define_method("load_at_most_ones_in_sat_presolve", &SatParameters::load_at_most_ones_in_sat_presolve) + .define_method("load_at_most_ones_in_sat_presolve=", &SatParameters::set_load_at_most_ones_in_sat_presolve) + .define_method("log_prefix", &SatParameters::log_prefix) + // .define_method("log_prefix=", &SatParameters::set_log_prefix) .define_method("log_search_progress", &SatParameters::log_search_progress) .define_method("log_search_progress=", &SatParameters::set_log_search_progress) + .define_method("log_subsolver_statistics", &SatParameters::log_subsolver_statistics) + .define_method("log_subsolver_statistics=", &SatParameters::set_log_subsolver_statistics) + .define_method("log_to_response", &SatParameters::log_to_response) + .define_method("log_to_response=", &SatParameters::set_log_to_response) + .define_method("log_to_stdout", &SatParameters::log_to_stdout) + .define_method("log_to_stdout=", &SatParameters::set_log_to_stdout) + .define_method("lp_dual_tolerance", &SatParameters::lp_dual_tolerance) + .define_method("lp_dual_tolerance=", &SatParameters::set_lp_dual_tolerance) + .define_method("lp_primal_tolerance", &SatParameters::lp_primal_tolerance) + .define_method("lp_primal_tolerance=", &SatParameters::set_lp_primal_tolerance) + .define_method("max_all_diff_cut_size", &SatParameters::max_all_diff_cut_size) + .define_method("max_all_diff_cut_size=", &SatParameters::set_max_all_diff_cut_size) + .define_method("max_alldiff_domain_size", &SatParameters::max_alldiff_domain_size) + .define_method("max_alldiff_domain_size=", &SatParameters::set_max_alldiff_domain_size) + .define_method("max_backjump_levels", &SatParameters::max_backjump_levels) + .define_method("max_backjump_levels=", &SatParameters::set_max_backjump_levels) + .define_method("max_clause_activity_value", &SatParameters::max_clause_activity_value) + .define_method("max_clause_activity_value=", &SatParameters::set_max_clause_activity_value) + .define_method("max_consecutive_inactive_count", &SatParameters::max_consecutive_inactive_count) + .define_method("max_consecutive_inactive_count=", &SatParameters::set_max_consecutive_inactive_count) + .define_method("max_cut_rounds_at_level_zero", &SatParameters::max_cut_rounds_at_level_zero) + .define_method("max_cut_rounds_at_level_zero=", &SatParameters::set_max_cut_rounds_at_level_zero) .define_method("max_deterministic_time", &SatParameters::max_deterministic_time) .define_method("max_deterministic_time=", &SatParameters::set_max_deterministic_time) + .define_method("max_domain_size_for_linear2_expansion", &SatParameters::max_domain_size_for_linear2_expansion) + .define_method("max_domain_size_for_linear2_expansion=", &SatParameters::set_max_domain_size_for_linear2_expansion) + .define_method("max_domain_size_when_encoding_eq_neq_constraints", &SatParameters::max_domain_size_when_encoding_eq_neq_constraints) + .define_method("max_domain_size_when_encoding_eq_neq_constraints=", &SatParameters::set_max_domain_size_when_encoding_eq_neq_constraints) + .define_method("max_drat_time_in_seconds", &SatParameters::max_drat_time_in_seconds) + .define_method("max_drat_time_in_seconds=", &SatParameters::set_max_drat_time_in_seconds) + .define_method("max_integer_rounding_scaling", &SatParameters::max_integer_rounding_scaling) + .define_method("max_integer_rounding_scaling=", &SatParameters::set_max_integer_rounding_scaling) + .define_method("max_lin_max_size_for_expansion", &SatParameters::max_lin_max_size_for_expansion) + .define_method("max_lin_max_size_for_expansion=", &SatParameters::set_max_lin_max_size_for_expansion) + .define_method("max_memory_in_mb", &SatParameters::max_memory_in_mb) + .define_method("max_memory_in_mb=", &SatParameters::set_max_memory_in_mb) + .define_method("max_num_cuts", &SatParameters::max_num_cuts) + .define_method("max_num_cuts=", &SatParameters::set_max_num_cuts) + .define_method("max_num_deterministic_batches", &SatParameters::max_num_deterministic_batches) + .define_method("max_num_deterministic_batches=", &SatParameters::set_max_num_deterministic_batches) + .define_method("max_num_intervals_for_timetable_edge_finding", &SatParameters::max_num_intervals_for_timetable_edge_finding) + .define_method("max_num_intervals_for_timetable_edge_finding=", &SatParameters::set_max_num_intervals_for_timetable_edge_finding) + .define_method("max_number_of_conflicts", &SatParameters::max_number_of_conflicts) + .define_method("max_number_of_conflicts=", &SatParameters::set_max_number_of_conflicts) + .define_method("max_pairs_pairwise_reasoning_in_no_overlap_2d", &SatParameters::max_pairs_pairwise_reasoning_in_no_overlap_2d) + .define_method("max_pairs_pairwise_reasoning_in_no_overlap_2d=", &SatParameters::set_max_pairs_pairwise_reasoning_in_no_overlap_2d) + .define_method("max_presolve_iterations", &SatParameters::max_presolve_iterations) + .define_method("max_presolve_iterations=", &SatParameters::set_max_presolve_iterations) + .define_method("max_sat_reverse_assumption_order", &SatParameters::max_sat_reverse_assumption_order) + .define_method("max_sat_reverse_assumption_order=", &SatParameters::set_max_sat_reverse_assumption_order) + .define_method("max_size_to_create_precedence_literals_in_disjunctive", &SatParameters::max_size_to_create_precedence_literals_in_disjunctive) + .define_method("max_size_to_create_precedence_literals_in_disjunctive=", &SatParameters::set_max_size_to_create_precedence_literals_in_disjunctive) .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("max_variable_activity_value", &SatParameters::max_variable_activity_value) + .define_method("max_variable_activity_value=", &SatParameters::set_max_variable_activity_value) + .define_method("maximum_regions_to_split_in_disconnected_no_overlap_2d", &SatParameters::maximum_regions_to_split_in_disconnected_no_overlap_2d) + .define_method("maximum_regions_to_split_in_disconnected_no_overlap_2d=", &SatParameters::set_maximum_regions_to_split_in_disconnected_no_overlap_2d) + .define_method("merge_at_most_one_work_limit", &SatParameters::merge_at_most_one_work_limit) + .define_method("merge_at_most_one_work_limit=", &SatParameters::set_merge_at_most_one_work_limit) + .define_method("merge_no_overlap_work_limit", &SatParameters::merge_no_overlap_work_limit) + .define_method("merge_no_overlap_work_limit=", &SatParameters::set_merge_no_overlap_work_limit) + .define_method("min_orthogonality_for_lp_constraints", &SatParameters::min_orthogonality_for_lp_constraints) + .define_method("min_orthogonality_for_lp_constraints=", &SatParameters::set_min_orthogonality_for_lp_constraints) + .define_method("minimize_reduction_during_pb_resolution", &SatParameters::minimize_reduction_during_pb_resolution) + .define_method("minimize_reduction_during_pb_resolution=", &SatParameters::set_minimize_reduction_during_pb_resolution) + .define_method("minimize_shared_clauses", &SatParameters::minimize_shared_clauses) + .define_method("minimize_shared_clauses=", &SatParameters::set_minimize_shared_clauses) + .define_method("mip_automatically_scale_variables", &SatParameters::mip_automatically_scale_variables) + .define_method("mip_automatically_scale_variables=", &SatParameters::set_mip_automatically_scale_variables) + .define_method("mip_check_precision", &SatParameters::mip_check_precision) + .define_method("mip_check_precision=", &SatParameters::set_mip_check_precision) + .define_method("mip_compute_true_objective_bound", &SatParameters::mip_compute_true_objective_bound) + .define_method("mip_compute_true_objective_bound=", &SatParameters::set_mip_compute_true_objective_bound) + .define_method("mip_drop_tolerance", &SatParameters::mip_drop_tolerance) + .define_method("mip_drop_tolerance=", &SatParameters::set_mip_drop_tolerance) + .define_method("mip_max_activity_exponent", &SatParameters::mip_max_activity_exponent) + .define_method("mip_max_activity_exponent=", &SatParameters::set_mip_max_activity_exponent) + .define_method("mip_max_bound", &SatParameters::mip_max_bound) + .define_method("mip_max_bound=", &SatParameters::set_mip_max_bound) + .define_method("mip_max_valid_magnitude", &SatParameters::mip_max_valid_magnitude) + .define_method("mip_max_valid_magnitude=", &SatParameters::set_mip_max_valid_magnitude) + .define_method("mip_presolve_level", &SatParameters::mip_presolve_level) + .define_method("mip_presolve_level=", &SatParameters::set_mip_presolve_level) + .define_method("mip_scale_large_domain", &SatParameters::mip_scale_large_domain) + .define_method("mip_scale_large_domain=", &SatParameters::set_mip_scale_large_domain) + .define_method("mip_treat_high_magnitude_bounds_as_infinity", &SatParameters::mip_treat_high_magnitude_bounds_as_infinity) + .define_method("mip_treat_high_magnitude_bounds_as_infinity=", &SatParameters::set_mip_treat_high_magnitude_bounds_as_infinity) + .define_method("mip_var_scaling", &SatParameters::mip_var_scaling) + .define_method("mip_var_scaling=", &SatParameters::set_mip_var_scaling) + .define_method("mip_wanted_precision", &SatParameters::mip_wanted_precision) + .define_method("mip_wanted_precision=", &SatParameters::set_mip_wanted_precision) + .define_method("name", &SatParameters::name) + // .define_method("name=", &SatParameters::set_name) + .define_method("new_constraints_batch_size", &SatParameters::new_constraints_batch_size) + .define_method("new_constraints_batch_size=", &SatParameters::set_new_constraints_batch_size) + .define_method("new_linear_propagation", &SatParameters::new_linear_propagation) + .define_method("new_linear_propagation=", &SatParameters::set_new_linear_propagation) + .define_method("no_overlap_2d_boolean_relations_limit", &SatParameters::no_overlap_2d_boolean_relations_limit) + .define_method("no_overlap_2d_boolean_relations_limit=", &SatParameters::set_no_overlap_2d_boolean_relations_limit) + .define_method("num_conflicts_before_strategy_changes", &SatParameters::num_conflicts_before_strategy_changes) + .define_method("num_conflicts_before_strategy_changes=", &SatParameters::set_num_conflicts_before_strategy_changes) + .define_method("num_full_subsolvers", &SatParameters::num_full_subsolvers) + .define_method("num_full_subsolvers=", &SatParameters::set_num_full_subsolvers) + .define_method("num_search_workers", &SatParameters::num_search_workers) + .define_method("num_search_workers=", &SatParameters::set_num_search_workers) + .define_method("num_violation_ls", &SatParameters::num_violation_ls) + .define_method("num_violation_ls=", &SatParameters::set_num_violation_ls) + .define_method("num_workers", &SatParameters::num_workers) + .define_method("num_workers=", &SatParameters::set_num_workers) + .define_method("only_add_cuts_at_level_zero", &SatParameters::only_add_cuts_at_level_zero) + .define_method("only_add_cuts_at_level_zero=", &SatParameters::set_only_add_cuts_at_level_zero) + .define_method("only_solve_ip", &SatParameters::only_solve_ip) + .define_method("only_solve_ip=", &SatParameters::set_only_solve_ip) + .define_method("optimize_with_core", &SatParameters::optimize_with_core) + .define_method("optimize_with_core=", &SatParameters::set_optimize_with_core) + .define_method("optimize_with_lb_tree_search", &SatParameters::optimize_with_lb_tree_search) + .define_method("optimize_with_lb_tree_search=", &SatParameters::set_optimize_with_lb_tree_search) + .define_method("optimize_with_max_hs", &SatParameters::optimize_with_max_hs) + .define_method("optimize_with_max_hs=", &SatParameters::set_optimize_with_max_hs) + .define_method("output_drat_proof", &SatParameters::output_drat_proof) + .define_method("output_drat_proof=", &SatParameters::set_output_drat_proof) + .define_method("output_lrat_proof", &SatParameters::output_lrat_proof) + .define_method("output_lrat_proof=", &SatParameters::set_output_lrat_proof) + .define_method("pb_cleanup_increment", &SatParameters::pb_cleanup_increment) + .define_method("pb_cleanup_increment=", &SatParameters::set_pb_cleanup_increment) + .define_method("pb_cleanup_ratio", &SatParameters::pb_cleanup_ratio) + .define_method("pb_cleanup_ratio=", &SatParameters::set_pb_cleanup_ratio) + .define_method("permute_presolve_constraint_order", &SatParameters::permute_presolve_constraint_order) + .define_method("permute_presolve_constraint_order=", &SatParameters::set_permute_presolve_constraint_order) + .define_method("permute_variable_randomly", &SatParameters::permute_variable_randomly) + .define_method("permute_variable_randomly=", &SatParameters::set_permute_variable_randomly) .define_method("polarity_exploit_ls_hints", &SatParameters::polarity_exploit_ls_hints) .define_method("polarity_exploit_ls_hints=", &SatParameters::set_polarity_exploit_ls_hints) .define_method("polarity_rephase_increment", &SatParameters::polarity_rephase_increment) .define_method("polarity_rephase_increment=", &SatParameters::set_polarity_rephase_increment) - .define_method("num_workers", &SatParameters::num_workers) - .define_method("num_workers=", &SatParameters::set_num_workers) + .define_method("polish_lp_solution", &SatParameters::polish_lp_solution) + .define_method("polish_lp_solution=", &SatParameters::set_polish_lp_solution) + .define_method("presolve_blocked_clause", &SatParameters::presolve_blocked_clause) + .define_method("presolve_blocked_clause=", &SatParameters::set_presolve_blocked_clause) + .define_method("presolve_bva_threshold", &SatParameters::presolve_bva_threshold) + .define_method("presolve_bva_threshold=", &SatParameters::set_presolve_bva_threshold) + .define_method("presolve_bve_clause_weight", &SatParameters::presolve_bve_clause_weight) + .define_method("presolve_bve_clause_weight=", &SatParameters::set_presolve_bve_clause_weight) + .define_method("presolve_bve_threshold", &SatParameters::presolve_bve_threshold) + .define_method("presolve_bve_threshold=", &SatParameters::set_presolve_bve_threshold) + .define_method("presolve_extract_integer_enforcement", &SatParameters::presolve_extract_integer_enforcement) + .define_method("presolve_extract_integer_enforcement=", &SatParameters::set_presolve_extract_integer_enforcement) + .define_method("presolve_inclusion_work_limit", &SatParameters::presolve_inclusion_work_limit) + .define_method("presolve_inclusion_work_limit=", &SatParameters::set_presolve_inclusion_work_limit) + .define_method("presolve_probing_deterministic_time_limit", &SatParameters::presolve_probing_deterministic_time_limit) + .define_method("presolve_probing_deterministic_time_limit=", &SatParameters::set_presolve_probing_deterministic_time_limit) + .define_method("presolve_substitution_level", &SatParameters::presolve_substitution_level) + .define_method("presolve_substitution_level=", &SatParameters::set_presolve_substitution_level) + .define_method("presolve_use_bva", &SatParameters::presolve_use_bva) + .define_method("presolve_use_bva=", &SatParameters::set_presolve_use_bva) + .define_method("probing_deterministic_time_limit", &SatParameters::probing_deterministic_time_limit) + .define_method("probing_deterministic_time_limit=", &SatParameters::set_probing_deterministic_time_limit) + .define_method("probing_num_combinations_limit", &SatParameters::probing_num_combinations_limit) + .define_method("probing_num_combinations_limit=", &SatParameters::set_probing_num_combinations_limit) + .define_method("propagation_loop_detection_factor", &SatParameters::propagation_loop_detection_factor) + .define_method("propagation_loop_detection_factor=", &SatParameters::set_propagation_loop_detection_factor) + .define_method("pseudo_cost_reliability_threshold", &SatParameters::pseudo_cost_reliability_threshold) + .define_method("pseudo_cost_reliability_threshold=", &SatParameters::set_pseudo_cost_reliability_threshold) + .define_method("push_all_tasks_toward_start", &SatParameters::push_all_tasks_toward_start) + .define_method("push_all_tasks_toward_start=", &SatParameters::set_push_all_tasks_toward_start) .define_method("random_branches_ratio", &SatParameters::random_branches_ratio) .define_method("random_branches_ratio=", &SatParameters::set_random_branches_ratio) .define_method("random_polarity_ratio", &SatParameters::random_polarity_ratio) .define_method("random_polarity_ratio=", &SatParameters::set_random_polarity_ratio) .define_method("random_seed", &SatParameters::random_seed) .define_method("random_seed=", &SatParameters::set_random_seed) + .define_method("randomize_search", &SatParameters::randomize_search) + .define_method("randomize_search=", &SatParameters::set_randomize_search) + .define_method("relative_gap_limit", &SatParameters::relative_gap_limit) + .define_method("relative_gap_limit=", &SatParameters::set_relative_gap_limit) + .define_method("remove_fixed_variables_early", &SatParameters::remove_fixed_variables_early) + .define_method("remove_fixed_variables_early=", &SatParameters::set_remove_fixed_variables_early) + .define_method("repair_hint", &SatParameters::repair_hint) + .define_method("repair_hint=", &SatParameters::set_repair_hint) + .define_method("restart_dl_average_ratio", &SatParameters::restart_dl_average_ratio) + .define_method("restart_dl_average_ratio=", &SatParameters::set_restart_dl_average_ratio) + .define_method("restart_lbd_average_ratio", &SatParameters::restart_lbd_average_ratio) + .define_method("restart_lbd_average_ratio=", &SatParameters::set_restart_lbd_average_ratio) + .define_method("restart_period", &SatParameters::restart_period) + .define_method("restart_period=", &SatParameters::set_restart_period) + .define_method("restart_running_window_size", &SatParameters::restart_running_window_size) + .define_method("restart_running_window_size=", &SatParameters::set_restart_running_window_size) + .define_method("root_lp_iterations", &SatParameters::root_lp_iterations) + .define_method("root_lp_iterations=", &SatParameters::set_root_lp_iterations) + .define_method("routing_cut_dp_effort", &SatParameters::routing_cut_dp_effort) + .define_method("routing_cut_dp_effort=", &SatParameters::set_routing_cut_dp_effort) + .define_method("routing_cut_max_infeasible_path_length", &SatParameters::routing_cut_max_infeasible_path_length) + .define_method("routing_cut_max_infeasible_path_length=", &SatParameters::set_routing_cut_max_infeasible_path_length) + .define_method("routing_cut_subset_size_for_binary_relation_bound", &SatParameters::routing_cut_subset_size_for_binary_relation_bound) + .define_method("routing_cut_subset_size_for_binary_relation_bound=", &SatParameters::set_routing_cut_subset_size_for_binary_relation_bound) + .define_method("routing_cut_subset_size_for_exact_binary_relation_bound", &SatParameters::routing_cut_subset_size_for_exact_binary_relation_bound) + .define_method("routing_cut_subset_size_for_exact_binary_relation_bound=", &SatParameters::set_routing_cut_subset_size_for_exact_binary_relation_bound) + .define_method("routing_cut_subset_size_for_shortest_paths_bound", &SatParameters::routing_cut_subset_size_for_shortest_paths_bound) + .define_method("routing_cut_subset_size_for_shortest_paths_bound=", &SatParameters::set_routing_cut_subset_size_for_shortest_paths_bound) + .define_method("routing_cut_subset_size_for_tight_binary_relation_bound", &SatParameters::routing_cut_subset_size_for_tight_binary_relation_bound) + .define_method("routing_cut_subset_size_for_tight_binary_relation_bound=", &SatParameters::set_routing_cut_subset_size_for_tight_binary_relation_bound) + .define_method("save_lp_basis_in_lb_tree_search", &SatParameters::save_lp_basis_in_lb_tree_search) + .define_method("save_lp_basis_in_lb_tree_search=", &SatParameters::set_save_lp_basis_in_lb_tree_search) + .define_method("search_random_variable_pool_size", &SatParameters::search_random_variable_pool_size) + .define_method("search_random_variable_pool_size=", &SatParameters::set_search_random_variable_pool_size) + .define_method("share_binary_clauses", &SatParameters::share_binary_clauses) + .define_method("share_binary_clauses=", &SatParameters::set_share_binary_clauses) + .define_method("share_glue_clauses", &SatParameters::share_glue_clauses) + .define_method("share_glue_clauses=", &SatParameters::set_share_glue_clauses) + .define_method("share_glue_clauses_dtime", &SatParameters::share_glue_clauses_dtime) + .define_method("share_glue_clauses_dtime=", &SatParameters::set_share_glue_clauses_dtime) + .define_method("share_level_zero_bounds", &SatParameters::share_level_zero_bounds) + .define_method("share_level_zero_bounds=", &SatParameters::set_share_level_zero_bounds) + .define_method("share_linear2_bounds", &SatParameters::share_linear2_bounds) + .define_method("share_linear2_bounds=", &SatParameters::set_share_linear2_bounds) + .define_method("share_objective_bounds", &SatParameters::share_objective_bounds) + .define_method("share_objective_bounds=", &SatParameters::set_share_objective_bounds) + .define_method("shared_tree_balance_tolerance", &SatParameters::shared_tree_balance_tolerance) + .define_method("shared_tree_balance_tolerance=", &SatParameters::set_shared_tree_balance_tolerance) + .define_method("shared_tree_max_nodes_per_worker", &SatParameters::shared_tree_max_nodes_per_worker) + .define_method("shared_tree_max_nodes_per_worker=", &SatParameters::set_shared_tree_max_nodes_per_worker) + .define_method("shared_tree_num_workers", &SatParameters::shared_tree_num_workers) + .define_method("shared_tree_num_workers=", &SatParameters::set_shared_tree_num_workers) + .define_method("shared_tree_open_leaves_per_worker", &SatParameters::shared_tree_open_leaves_per_worker) + .define_method("shared_tree_open_leaves_per_worker=", &SatParameters::set_shared_tree_open_leaves_per_worker) + .define_method("shared_tree_split_min_dtime", &SatParameters::shared_tree_split_min_dtime) + .define_method("shared_tree_split_min_dtime=", &SatParameters::set_shared_tree_split_min_dtime) + .define_method("shared_tree_worker_enable_phase_sharing", &SatParameters::shared_tree_worker_enable_phase_sharing) + .define_method("shared_tree_worker_enable_phase_sharing=", &SatParameters::set_shared_tree_worker_enable_phase_sharing) + .define_method("shared_tree_worker_enable_trail_sharing", &SatParameters::shared_tree_worker_enable_trail_sharing) + .define_method("shared_tree_worker_enable_trail_sharing=", &SatParameters::set_shared_tree_worker_enable_trail_sharing) + .define_method("shared_tree_worker_min_restarts_per_subtree", &SatParameters::shared_tree_worker_min_restarts_per_subtree) + .define_method("shared_tree_worker_min_restarts_per_subtree=", &SatParameters::set_shared_tree_worker_min_restarts_per_subtree) + .define_method("shaving_deterministic_time_in_probing_search", &SatParameters::shaving_deterministic_time_in_probing_search) + .define_method("shaving_deterministic_time_in_probing_search=", &SatParameters::set_shaving_deterministic_time_in_probing_search) + .define_method("shaving_search_deterministic_time", &SatParameters::shaving_search_deterministic_time) + .define_method("shaving_search_deterministic_time=", &SatParameters::set_shaving_search_deterministic_time) + .define_method("shaving_search_threshold", &SatParameters::shaving_search_threshold) + .define_method("shaving_search_threshold=", &SatParameters::set_shaving_search_threshold) + .define_method("solution_pool_diversity_limit", &SatParameters::solution_pool_diversity_limit) + .define_method("solution_pool_diversity_limit=", &SatParameters::set_solution_pool_diversity_limit) + .define_method("solution_pool_size", &SatParameters::solution_pool_size) + .define_method("solution_pool_size=", &SatParameters::set_solution_pool_size) + .define_method("stop_after_first_solution", &SatParameters::stop_after_first_solution) + .define_method("stop_after_first_solution=", &SatParameters::set_stop_after_first_solution) + .define_method("stop_after_presolve", &SatParameters::stop_after_presolve) + .define_method("stop_after_presolve=", &SatParameters::set_stop_after_presolve) + .define_method("stop_after_root_propagation", &SatParameters::stop_after_root_propagation) + .define_method("stop_after_root_propagation=", &SatParameters::set_stop_after_root_propagation) + .define_method("strategy_change_increase_ratio", &SatParameters::strategy_change_increase_ratio) + .define_method("strategy_change_increase_ratio=", &SatParameters::set_strategy_change_increase_ratio) + .define_method("subsume_during_vivification", &SatParameters::subsume_during_vivification) + .define_method("subsume_during_vivification=", &SatParameters::set_subsume_during_vivification) + .define_method("subsumption_during_conflict_analysis", &SatParameters::subsumption_during_conflict_analysis) + .define_method("subsumption_during_conflict_analysis=", &SatParameters::set_subsumption_during_conflict_analysis) + .define_method("symmetry_detection_deterministic_time_limit", &SatParameters::symmetry_detection_deterministic_time_limit) + .define_method("symmetry_detection_deterministic_time_limit=", &SatParameters::set_symmetry_detection_deterministic_time_limit) + .define_method("symmetry_level", &SatParameters::symmetry_level) + .define_method("symmetry_level=", &SatParameters::set_symmetry_level) + .define_method("table_compression_level", &SatParameters::table_compression_level) + .define_method("table_compression_level=", &SatParameters::set_table_compression_level) + .define_method("transitive_precedences_work_limit", &SatParameters::transitive_precedences_work_limit) + .define_method("transitive_precedences_work_limit=", &SatParameters::set_transitive_precedences_work_limit) + .define_method("use_absl_random", &SatParameters::use_absl_random) + .define_method("use_absl_random=", &SatParameters::set_use_absl_random) + .define_method("use_all_different_for_circuit", &SatParameters::use_all_different_for_circuit) + .define_method("use_all_different_for_circuit=", &SatParameters::set_use_all_different_for_circuit) + .define_method("use_area_energetic_reasoning_in_no_overlap_2d", &SatParameters::use_area_energetic_reasoning_in_no_overlap_2d) + .define_method("use_area_energetic_reasoning_in_no_overlap_2d=", &SatParameters::set_use_area_energetic_reasoning_in_no_overlap_2d) + .define_method("use_blocking_restart", &SatParameters::use_blocking_restart) + .define_method("use_blocking_restart=", &SatParameters::set_use_blocking_restart) + .define_method("use_chronological_backtracking", &SatParameters::use_chronological_backtracking) + .define_method("use_chronological_backtracking=", &SatParameters::set_use_chronological_backtracking) + .define_method("use_combined_no_overlap", &SatParameters::use_combined_no_overlap) + .define_method("use_combined_no_overlap=", &SatParameters::set_use_combined_no_overlap) + .define_method("use_conservative_scale_overload_checker", &SatParameters::use_conservative_scale_overload_checker) + .define_method("use_conservative_scale_overload_checker=", &SatParameters::set_use_conservative_scale_overload_checker) + .define_method("use_disjunctive_constraint_in_cumulative", &SatParameters::use_disjunctive_constraint_in_cumulative) + .define_method("use_disjunctive_constraint_in_cumulative=", &SatParameters::set_use_disjunctive_constraint_in_cumulative) + .define_method("use_dual_scheduling_heuristics", &SatParameters::use_dual_scheduling_heuristics) + .define_method("use_dual_scheduling_heuristics=", &SatParameters::set_use_dual_scheduling_heuristics) + .define_method("use_dynamic_precedence_in_cumulative", &SatParameters::use_dynamic_precedence_in_cumulative) + .define_method("use_dynamic_precedence_in_cumulative=", &SatParameters::set_use_dynamic_precedence_in_cumulative) + .define_method("use_dynamic_precedence_in_disjunctive", &SatParameters::use_dynamic_precedence_in_disjunctive) + .define_method("use_dynamic_precedence_in_disjunctive=", &SatParameters::set_use_dynamic_precedence_in_disjunctive) + .define_method("use_energetic_reasoning_in_no_overlap_2d", &SatParameters::use_energetic_reasoning_in_no_overlap_2d) + .define_method("use_energetic_reasoning_in_no_overlap_2d=", &SatParameters::set_use_energetic_reasoning_in_no_overlap_2d) .define_method("use_erwa_heuristic", &SatParameters::use_erwa_heuristic) .define_method("use_erwa_heuristic=", &SatParameters::set_use_erwa_heuristic) + .define_method("use_exact_lp_reason", &SatParameters::use_exact_lp_reason) + .define_method("use_exact_lp_reason=", &SatParameters::set_use_exact_lp_reason) + .define_method("use_extended_probing", &SatParameters::use_extended_probing) + .define_method("use_extended_probing=", &SatParameters::set_use_extended_probing) + .define_method("use_feasibility_jump", &SatParameters::use_feasibility_jump) + .define_method("use_feasibility_jump=", &SatParameters::set_use_feasibility_jump) + .define_method("use_feasibility_pump", &SatParameters::use_feasibility_pump) + .define_method("use_feasibility_pump=", &SatParameters::set_use_feasibility_pump) + .define_method("use_hard_precedences_in_cumulative", &SatParameters::use_hard_precedences_in_cumulative) + .define_method("use_hard_precedences_in_cumulative=", &SatParameters::set_use_hard_precedences_in_cumulative) + .define_method("use_implied_bounds", &SatParameters::use_implied_bounds) + .define_method("use_implied_bounds=", &SatParameters::set_use_implied_bounds) + .define_method("use_lb_relax_lns", &SatParameters::use_lb_relax_lns) + .define_method("use_lb_relax_lns=", &SatParameters::set_use_lb_relax_lns) + .define_method("use_linear3_for_no_overlap_2d_precedences", &SatParameters::use_linear3_for_no_overlap_2d_precedences) + .define_method("use_linear3_for_no_overlap_2d_precedences=", &SatParameters::set_use_linear3_for_no_overlap_2d_precedences) + .define_method("use_lns", &SatParameters::use_lns) + .define_method("use_lns=", &SatParameters::set_use_lns) + .define_method("use_lns_only", &SatParameters::use_lns_only) + .define_method("use_lns_only=", &SatParameters::set_use_lns_only) + .define_method("use_ls_only", &SatParameters::use_ls_only) + .define_method("use_ls_only=", &SatParameters::set_use_ls_only) + .define_method("use_new_integer_conflict_resolution", &SatParameters::use_new_integer_conflict_resolution) + .define_method("use_new_integer_conflict_resolution=", &SatParameters::set_use_new_integer_conflict_resolution) + .define_method("use_objective_lb_search", &SatParameters::use_objective_lb_search) + .define_method("use_objective_lb_search=", &SatParameters::set_use_objective_lb_search) + .define_method("use_objective_shaving_search", &SatParameters::use_objective_shaving_search) + .define_method("use_objective_shaving_search=", &SatParameters::set_use_objective_shaving_search) + .define_method("use_optimization_hints", &SatParameters::use_optimization_hints) + .define_method("use_optimization_hints=", &SatParameters::set_use_optimization_hints) + .define_method("use_optional_variables", &SatParameters::use_optional_variables) + .define_method("use_optional_variables=", &SatParameters::set_use_optional_variables) + .define_method("use_overload_checker_in_cumulative", &SatParameters::use_overload_checker_in_cumulative) + .define_method("use_overload_checker_in_cumulative=", &SatParameters::set_use_overload_checker_in_cumulative) + .define_method("use_pb_resolution", &SatParameters::use_pb_resolution) + .define_method("use_pb_resolution=", &SatParameters::set_use_pb_resolution) .define_method("use_phase_saving", &SatParameters::use_phase_saving) - .define_method("use_phase_saving=", &SatParameters::set_use_phase_saving); + .define_method("use_phase_saving=", &SatParameters::set_use_phase_saving) + .define_method("use_precedences_in_disjunctive_constraint", &SatParameters::use_precedences_in_disjunctive_constraint) + .define_method("use_precedences_in_disjunctive_constraint=", &SatParameters::set_use_precedences_in_disjunctive_constraint) + .define_method("use_probing_search", &SatParameters::use_probing_search) + .define_method("use_probing_search=", &SatParameters::set_use_probing_search) + .define_method("use_rins_lns", &SatParameters::use_rins_lns) + .define_method("use_rins_lns=", &SatParameters::set_use_rins_lns) + .define_method("use_sat_inprocessing", &SatParameters::use_sat_inprocessing) + .define_method("use_sat_inprocessing=", &SatParameters::set_use_sat_inprocessing) + .define_method("use_shared_tree_search", &SatParameters::use_shared_tree_search) + .define_method("use_shared_tree_search=", &SatParameters::set_use_shared_tree_search) + .define_method("use_strong_propagation_in_disjunctive", &SatParameters::use_strong_propagation_in_disjunctive) + .define_method("use_strong_propagation_in_disjunctive=", &SatParameters::set_use_strong_propagation_in_disjunctive) + .define_method("use_symmetry_in_lp", &SatParameters::use_symmetry_in_lp) + .define_method("use_symmetry_in_lp=", &SatParameters::set_use_symmetry_in_lp) + .define_method("use_timetable_edge_finding_in_cumulative", &SatParameters::use_timetable_edge_finding_in_cumulative) + .define_method("use_timetable_edge_finding_in_cumulative=", &SatParameters::set_use_timetable_edge_finding_in_cumulative) + .define_method("use_timetabling_in_no_overlap_2d", &SatParameters::use_timetabling_in_no_overlap_2d) + .define_method("use_timetabling_in_no_overlap_2d=", &SatParameters::set_use_timetabling_in_no_overlap_2d) + .define_method("use_try_edge_reasoning_in_no_overlap_2d", &SatParameters::use_try_edge_reasoning_in_no_overlap_2d) + .define_method("use_try_edge_reasoning_in_no_overlap_2d=", &SatParameters::set_use_try_edge_reasoning_in_no_overlap_2d) + .define_method("variable_activity_decay", &SatParameters::variable_activity_decay) + .define_method("variable_activity_decay=", &SatParameters::set_variable_activity_decay) + .define_method("variables_shaving_level", &SatParameters::variables_shaving_level) + .define_method("variables_shaving_level=", &SatParameters::set_variables_shaving_level) + .define_method("violation_ls_compound_move_probability", &SatParameters::violation_ls_compound_move_probability) + .define_method("violation_ls_compound_move_probability=", &SatParameters::set_violation_ls_compound_move_probability) + .define_method("violation_ls_perturbation_period", &SatParameters::violation_ls_perturbation_period) + .define_method("violation_ls_perturbation_period=", &SatParameters::set_violation_ls_perturbation_period); Rice::define_class_under(m, "CpModel") .define_constructor(Rice::Constructor()) From b11c82291baa20a203770006854a5b2baa5f95d2 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Thu, 1 Oct 2026 15:46:15 -0700 Subject: [PATCH 10/13] Updated changelog [skip ci] --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index d3d0a06..9087e81 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,6 +1,7 @@ ## 0.18.1 (unreleased) - Added support for breaks for routing +- Added support for more constraints for routing - Added more methods to `SatParameters` ## 0.18.0 (2026-07-06) From cbd573dc2c3eda578f247e467a490ea4bd4764d1 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Thu, 1 Oct 2026 15:56:58 -0700 Subject: [PATCH 11/13] Updated read_assignment_from_routes to release GVL when possible - #87 Co-authored-by: Eric Kreutzer --- ext/or-tools/routing.cpp | 12 +++++++++++- lib/or_tools/routing_model.rb | 4 ++++ 2 files changed, 15 insertions(+), 1 deletion(-) diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index efa5da3..fd4971d 100644 --- a/ext/or-tools/routing.cpp +++ b/ext/or-tools/routing.cpp @@ -555,7 +555,17 @@ void init_routing(Rice::Module& m) { .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>& 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) diff --git a/lib/or_tools/routing_model.rb b/lib/or_tools/routing_model.rb index 8581bb4..f87760e 100644 --- a/lib/or_tools/routing_model.rb +++ b/lib/or_tools/routing_model.rb @@ -30,6 +30,10 @@ 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) From a000fa6be788f05fa2fa9ab631ef6e24d85fc4ab Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Thu, 1 Oct 2026 16:19:13 -0700 Subject: [PATCH 12/13] Simplified code [skip ci] --- ext/or-tools/routing.cpp | 12 ++---------- 1 file changed, 2 insertions(+), 10 deletions(-) diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index fd4971d..64ae4ed 100644 --- a/ext/or-tools/routing.cpp +++ b/ext/or-tools/routing.cpp @@ -197,16 +197,8 @@ void init_routing(Rice::Module& m) { 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("log_search=", &RoutingSearchParameters::set_log_search) + .define_method("solution_limit=", &RoutingSearchParameters::set_solution_limit) .define_method( "time_limit=", [](RoutingSearchParameters& self, int64_t value) { From ea3c4dd26069491480e6ae496f5285600dc32ad3 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Thu, 1 Oct 2026 16:56:38 -0700 Subject: [PATCH 13/13] Added more methods to ConstraintSolverParameters, RoutingModelParameters, and RoutingSearchParameters [skip ci] --- CHANGELOG.md | 3 + ext/or-tools/routing.cpp | 128 +++++++++++++++++++++++++++++++++++---- 2 files changed, 119 insertions(+), 12 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 9087e81..932a38f 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,9 @@ - Added support for breaks for routing - Added support for more constraints for routing +- Added more methods to `ConstraintSolverParameters` +- Added more methods to `RoutingModelParameters` +- Added more methods to `RoutingSearchParameters` - Added more methods to `SatParameters` ## 0.18.0 (2026-07-06) diff --git a/ext/or-tools/routing.cpp b/ext/or-tools/routing.cpp index 64ae4ed..611a083 100644 --- a/ext/or-tools/routing.cpp +++ b/ext/or-tools/routing.cpp @@ -137,6 +137,66 @@ void init_routing(Rice::Module& m) { m.define_singleton_function("default_routing_search_parameters", &DefaultRoutingSearchParameters); 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) { @@ -197,8 +257,6 @@ void init_routing(Rice::Module& m) { return self.set_local_search_metaheuristic(v); }) - .define_method("log_search=", &RoutingSearchParameters::set_log_search) - .define_method("solution_limit=", &RoutingSearchParameters::set_solution_limit) .define_method( "time_limit=", [](RoutingSearchParameters& self, int64_t value) { @@ -368,18 +426,64 @@ void init_routing(Rice::Module& m) { }); Rice::define_class_under(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(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) {