or-tools 0.4.3 → 0.5.3

data/ext/or-tools/ext.cpp

@@ -1,6 +1,6 @@
 #include <ortools/base/version.h>
 
-#include <rice/Module.hpp>
+#include "ext.h"
 
 void init_assignment(Rice::Module& m);
 void init_bin_packing(Rice::Module& m);
@@ -14,9 +14,9 @@ void Init_ext()
 {
   auto m = Rice::define_module("ORTools");
 
-  m.define_singleton_method(
+  m.define_singleton_function(
     "lib_version",
-    *[]() {
+    []() {
       return std::to_string(operations_research::OrToolsMajorVersion()) + "."
         + std::to_string(operations_research::OrToolsMinorVersion());
     });

data/ext/or-tools/ext.h

@@ -0,0 +1,4 @@
+#pragma once
+
+#include <rice/rice.hpp>
+#include <rice/stl.hpp>

data/ext/or-tools/extconf.rb

@@ -1,8 +1,6 @@
 require "mkmf-rice"
 
-raise "Missing stdc++" unless have_library("stdc++")
-
-$CXXFLAGS << " -std=c++17 -DUSE_CBC"
+$CXXFLAGS << " -std=c++17 $(optflags) -DUSE_CBC"
 
 # or-tools warnings
 $CXXFLAGS << " -Wno-sign-compare -Wno-shorten-64-to-32 -Wno-ignored-qualifiers"

data/ext/or-tools/linear.cpp

@@ -1,11 +1,6 @@
 #include <ortools/linear_solver/linear_solver.h>
 
-#include <rice/Array.hpp>
-#include <rice/Class.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
-#include <rice/String.hpp>
-#include <rice/Symbol.hpp>
+#include "ext.h"
 
 using operations_research::LinearExpr;
 using operations_research::LinearRange;
@@ -21,141 +16,135 @@ using Rice::Object;
 using Rice::String;
 using Rice::Symbol;
 
-template<>
-inline
-MPSolver::OptimizationProblemType from_ruby<MPSolver::OptimizationProblemType>(Object x)
+namespace Rice::detail
 {
-  std::string s = Symbol(x).str();
-  if (s == "glop") {
-    return MPSolver::OptimizationProblemType::GLOP_LINEAR_PROGRAMMING;
-  } else if (s == "cbc") {
-    return MPSolver::OptimizationProblemType::CBC_MIXED_INTEGER_PROGRAMMING;
-  } else {
-    throw std::runtime_error("Unknown optimization problem type: " + s);
-  }
-}
-
-Class rb_cMPVariable;
-Class rb_cMPConstraint;
-Class rb_cMPObjective;
-
-template<>
-inline
-Object to_ruby<MPVariable*>(MPVariable* const &x)
-{
-  return Rice::Data_Object<MPVariable>(x, rb_cMPVariable, nullptr, nullptr);
-}
+  template<>
+  struct Type<MPSolver::OptimizationProblemType>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
 
-template<>
-inline
-Object to_ruby<MPConstraint*>(MPConstraint* const &x)
-{
-  return Rice::Data_Object<MPConstraint>(x, rb_cMPConstraint, nullptr, nullptr);
-}
-
-template<>
-inline
-Object to_ruby<MPObjective*>(MPObjective* const &x)
-{
-  return Rice::Data_Object<MPObjective>(x, rb_cMPObjective, nullptr, nullptr);
+  template<>
+  struct From_Ruby<MPSolver::OptimizationProblemType>
+  {
+    static MPSolver::OptimizationProblemType convert(VALUE x)
+    {
+      auto s = Symbol(x).str();
+      if (s == "glop") {
+        return MPSolver::OptimizationProblemType::GLOP_LINEAR_PROGRAMMING;
+      } else if (s == "cbc") {
+        return MPSolver::OptimizationProblemType::CBC_MIXED_INTEGER_PROGRAMMING;
+      } else {
+        throw std::runtime_error("Unknown optimization problem type: " + s);
+      }
+    }
+  };
 }
 
 void init_linear(Rice::Module& m) {
-  rb_cMPVariable = Rice::define_class_under<MPVariable>(m, "MPVariable")
+  Rice::define_class_under<LinearRange>(m, "LinearRange");
+  auto rb_cLinearExpr = Rice::define_class_under<LinearExpr>(m, "LinearExpr");
+
+  Rice::define_class_under<MPVariable>(m, "MPVariable")
     .define_method("name", &MPVariable::name)
     .define_method("solution_value", &MPVariable::solution_value)
     .define_method(
       "+",
-      *[](MPVariable& self, LinearExpr& other) {
+      [](MPVariable& self, LinearExpr& other) {
         LinearExpr s(&self);
         return s + other;
       })
     .define_method(
       "-",
-      *[](MPVariable& self, LinearExpr& other) {
+      [](MPVariable& self, LinearExpr& other) {
         LinearExpr s(&self);
         return s - other;
       })
     .define_method(
       "*",
-      *[](MPVariable& self, double other) {
+      [](MPVariable& self, double other) {
         LinearExpr s(&self);
         return s * other;
       })
     .define_method(
       "inspect",
-      *[](MPVariable& self) {
+      [](MPVariable& self) {
         return "#<ORTools::MPVariable @name=\"" + self.name() + "\">";
       });
 
-  Rice::define_class_under<LinearExpr>(m, "LinearExpr")
+  rb_cLinearExpr
     .define_constructor(Rice::Constructor<LinearExpr>())
     .define_method(
       "_add_linear_expr",
-      *[](LinearExpr& self, LinearExpr& other) {
+      [](LinearExpr& self, LinearExpr& other) {
         return self + other;
       })
     .define_method(
       "_add_mp_variable",
-      *[](LinearExpr& self, MPVariable &other) {
+      [](LinearExpr& self, MPVariable &other) {
         LinearExpr o(&other);
         return self + o;
       })
     .define_method(
       "_gte_double",
-      *[](LinearExpr& self, double other) {
+      [](LinearExpr& self, double other) {
         LinearExpr o(other);
         return self >= o;
       })
     .define_method(
       "_gte_linear_expr",
-      *[](LinearExpr& self, LinearExpr& other) {
+      [](LinearExpr& self, LinearExpr& other) {
         return self >= other;
       })
     .define_method(
       "_lte_double",
-      *[](LinearExpr& self, double other) {
+      [](LinearExpr& self, double other) {
         LinearExpr o(other);
         return self <= o;
       })
     .define_method(
       "_lte_linear_expr",
-      *[](LinearExpr& self, LinearExpr& other) {
+      [](LinearExpr& self, LinearExpr& other) {
         return self <= other;
       })
     .define_method(
       "==",
-      *[](LinearExpr& self, double other) {
+      [](LinearExpr& self, double other) {
         LinearExpr o(other);
         return self == o;
       })
     .define_method(
       "to_s",
-      *[](LinearExpr& self) {
+      [](LinearExpr& self) {
         return self.ToString();
       })
     .define_method(
       "inspect",
-      *[](LinearExpr& self) {
+      [](LinearExpr& self) {
         return "#<ORTools::LinearExpr \"" + self.ToString() + "\">";
       });
 
-  Rice::define_class_under<LinearRange>(m, "LinearRange");
-
-  rb_cMPConstraint = Rice::define_class_under<MPConstraint>(m, "MPConstraint")
+  Rice::define_class_under<MPConstraint>(m, "MPConstraint")
     .define_method("set_coefficient", &MPConstraint::SetCoefficient);
 
-  rb_cMPObjective = Rice::define_class_under<MPObjective>(m, "MPObjective")
+  Rice::define_class_under<MPObjective>(m, "MPObjective")
     .define_method("value", &MPObjective::Value)
     .define_method("set_coefficient", &MPObjective::SetCoefficient)
     .define_method("set_maximization", &MPObjective::SetMaximization);
 
   Rice::define_class_under<MPSolver>(m, "Solver")
     .define_constructor(Rice::Constructor<MPSolver, std::string, MPSolver::OptimizationProblemType>())
-    .define_method("infinity", &MPSolver::infinity)
+    .define_method(
+      "infinity",
+      [](MPSolver& self) {
+        return self.infinity();
+      })
     .define_method(
       "int_var",
-      *[](MPSolver& self, double min, double max, const std::string& name) {
+      [](MPSolver& self, double min, double max, const std::string& name) {
         return self.MakeIntVar(min, max, name);
       })
     .define_method("num_var", &MPSolver::MakeNumVar)
@@ -168,27 +157,27 @@ void init_linear(Rice::Module& m) {
     .define_method("objective", &MPSolver::MutableObjective)
     .define_method(
       "maximize",
-      *[](MPSolver& self, LinearExpr& expr) {
+      [](MPSolver& self, LinearExpr& expr) {
         return self.MutableObjective()->MaximizeLinearExpr(expr);
       })
     .define_method(
       "minimize",
-      *[](MPSolver& self, LinearExpr& expr) {
+      [](MPSolver& self, LinearExpr& expr) {
         return self.MutableObjective()->MinimizeLinearExpr(expr);
       })
     .define_method(
       "add",
-      *[](MPSolver& self, const LinearRange& range) {
+      [](MPSolver& self, const LinearRange& range) {
         return self.MakeRowConstraint(range);
       })
     .define_method(
       "constraint",
-      *[](MPSolver& self, double lb, double ub) {
+      [](MPSolver& self, double lb, double ub) {
         return self.MakeRowConstraint(lb, ub);
       })
     .define_method(
       "solve",
-      *[](MPSolver& self) {
+      [](MPSolver& self) {
         auto status = self.Solve();
 
         if (status == MPSolver::ResultStatus::OPTIMAL) {
@@ -208,5 +197,23 @@ void init_linear(Rice::Module& m) {
         } else {
           throw std::runtime_error("Unknown status");
         }
+      })
+    .define_method(
+      "export_model_as_lp_format",
+      [](MPSolver& self, bool obfuscate) {
+        std::string model_str;
+        if (!self.ExportModelAsLpFormat(obfuscate, &model_str)) {
+          throw std::runtime_error("Export failed");
+        }
+        return model_str;
+      })
+    .define_method(
+      "export_model_as_mps_format",
+      [](MPSolver& self, bool fixed_format, bool obfuscate) {
+        std::string model_str;
+        if (!self.ExportModelAsMpsFormat(fixed_format, obfuscate, &model_str)) {
+          throw std::runtime_error("Export failed");
+        }
+        return model_str;
       });
 }

data/ext/or-tools/network_flows.cpp

@@ -1,9 +1,7 @@
 #include <ortools/graph/max_flow.h>
 #include <ortools/graph/min_cost_flow.h>
 
-#include <rice/Array.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
+#include "ext.h"
 
 using operations_research::NodeIndex;
 using operations_research::SimpleMaxFlow;
@@ -25,7 +23,7 @@ void init_network_flows(Rice::Module& m) {
     .define_method("flow", &SimpleMaxFlow::Flow)
     .define_method(
       "solve",
-      *[](SimpleMaxFlow& self, NodeIndex source, NodeIndex sink) {
+      [](SimpleMaxFlow& self, NodeIndex source, NodeIndex sink) {
         auto status = self.Solve(source, sink);
 
         if (status == SimpleMaxFlow::Status::OPTIMAL) {
@@ -42,24 +40,24 @@ void init_network_flows(Rice::Module& m) {
       })
     .define_method(
       "source_side_min_cut",
-      *[](SimpleMaxFlow& self) {
+      [](SimpleMaxFlow& self) {
         std::vector<NodeIndex> result;
         self.GetSourceSideMinCut(&result);
 
         Array ret;
-        for(auto const& it: result) {
+        for (const auto& it : result) {
           ret.push(it);
         }
         return ret;
       })
     .define_method(
       "sink_side_min_cut",
-      *[](SimpleMaxFlow& self) {
+      [](SimpleMaxFlow& self) {
         std::vector<NodeIndex> result;
         self.GetSinkSideMinCut(&result);
 
         Array ret;
-        for(auto const& it: result) {
+        for (const auto& it : result) {
           ret.push(it);
         }
         return ret;
@@ -81,7 +79,7 @@ void init_network_flows(Rice::Module& m) {
     .define_method("unit_cost", &SimpleMinCostFlow::UnitCost)
     .define_method(
       "solve",
-      *[](SimpleMinCostFlow& self) {
+      [](SimpleMinCostFlow& self) {
         auto status = self.Solve();
 
         if (status == SimpleMinCostFlow::Status::NOT_SOLVED) {

data/ext/or-tools/routing.cpp

@@ -1,19 +1,17 @@
 #include <ortools/constraint_solver/routing.h>
 #include <ortools/constraint_solver/routing_parameters.h>
 
-#include <rice/Array.hpp>
-#include <rice/Class.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
-#include <rice/String.hpp>
-#include <rice/Symbol.hpp>
+#include "ext.h"
 
+using operations_research::Assignment;
+using operations_research::ConstraintSolverParameters;
 using operations_research::DefaultRoutingSearchParameters;
 using operations_research::FirstSolutionStrategy;
 using operations_research::LocalSearchMetaheuristic;
 using operations_research::RoutingDimension;
 using operations_research::RoutingIndexManager;
 using operations_research::RoutingModel;
+using operations_research::RoutingModelParameters;
 using operations_research::RoutingNodeIndex;
 using operations_research::RoutingSearchParameters;
 
@@ -24,99 +22,50 @@ using Rice::Object;
 using Rice::String;
 using Rice::Symbol;
 
-template<>
-inline
-RoutingNodeIndex from_ruby<RoutingNodeIndex>(Object x)
+namespace Rice::detail
 {
-  const RoutingNodeIndex index{from_ruby<int>(x)};
-  return index;
-}
-
-template<>
-inline
-Object to_ruby<RoutingNodeIndex>(RoutingNodeIndex const &x)
-{
-  return to_ruby<int>(x.value());
-}
-
-std::vector<RoutingNodeIndex> nodeIndexVector(Array x) {
-  std::vector<RoutingNodeIndex> res;
-  for (auto const& v : x) {
-    res.push_back(from_ruby<RoutingNodeIndex>(v));
-  }
-  return res;
-}
+  template<>
+  struct Type<RoutingNodeIndex>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
 
-// need a wrapper class due to const
-class Assignment {
-  const operations_research::Assignment* self;
+  template<>
+  class From_Ruby<RoutingNodeIndex>
+  {
   public:
-    Assignment(const operations_research::Assignment* v) {
-      self = v;
-    }
-    int64 ObjectiveValue() {
-      return self->ObjectiveValue();
-    }
-    int64 Value(const operations_research::IntVar* const var) const {
-      return self->Value(var);
-    }
-    int64 Min(const operations_research::IntVar* const var) const {
-      return self->Min(var);
-    }
-    int64 Max(const operations_research::IntVar* const var) const {
-      return self->Max(var);
+    RoutingNodeIndex convert(VALUE x)
+    {
+      const RoutingNodeIndex index{From_Ruby<int>().convert(x)};
+      return index;
     }
-};
-
-Class rb_cIntVar;
-Class rb_cIntervalVar;
-Class rb_cRoutingDimension;
-Class rb_cConstraint;
-Class rb_cSolver2;
-
-template<>
-inline
-Object to_ruby<operations_research::IntVar*>(operations_research::IntVar* const &x)
-{
-  return Rice::Data_Object<operations_research::IntVar>(x, rb_cIntVar, nullptr, nullptr);
-}
-
-template<>
-inline
-Object to_ruby<operations_research::IntervalVar*>(operations_research::IntervalVar* const &x)
-{
-  return Rice::Data_Object<operations_research::IntervalVar>(x, rb_cIntervalVar, nullptr, nullptr);
-}
-
-template<>
-inline
-Object to_ruby<RoutingDimension*>(RoutingDimension* const &x)
-{
-  return Rice::Data_Object<RoutingDimension>(x, rb_cRoutingDimension, nullptr, nullptr);
-}
+  };
 
-template<>
-inline
-Object to_ruby<operations_research::Constraint*>(operations_research::Constraint* const &x)
-{
-  return Rice::Data_Object<operations_research::Constraint>(x, rb_cConstraint, nullptr, nullptr);
-}
-
-template<>
-inline
-Object to_ruby<operations_research::Solver*>(operations_research::Solver* const &x)
-{
-  return Rice::Data_Object<operations_research::Solver>(x, rb_cSolver2, nullptr, nullptr);
+  template<>
+  class To_Ruby<RoutingNodeIndex>
+  {
+  public:
+    VALUE convert(RoutingNodeIndex const & x)
+    {
+      return To_Ruby<int>().convert(x.value());
+    }
+  };
 }
 
 void init_routing(Rice::Module& m) {
-  m.define_singleton_method("default_routing_search_parameters", &DefaultRoutingSearchParameters);
+  auto rb_cRoutingSearchParameters = Rice::define_class_under<RoutingSearchParameters>(m, "RoutingSearchParameters");
+  auto rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "IntVar");
 
-  Rice::define_class_under<RoutingSearchParameters>(m, "RoutingSearchParameters")
+  m.define_singleton_function("default_routing_search_parameters", &DefaultRoutingSearchParameters);
+
+  rb_cRoutingSearchParameters
     .define_method(
       "first_solution_strategy=",
-      *[](RoutingSearchParameters& self, Symbol value) {
-        std::string s = Symbol(value).str();
+      [](RoutingSearchParameters& self, Symbol value) {
+        auto s = Symbol(value).str();
 
         FirstSolutionStrategy::Value v;
         if (s == "path_cheapest_arc") {
@@ -155,8 +104,8 @@ void init_routing(Rice::Module& m) {
       })
     .define_method(
       "local_search_metaheuristic=",
-      *[](RoutingSearchParameters& self, Symbol value) {
-        std::string s = Symbol(value).str();
+      [](RoutingSearchParameters& self, Symbol value) {
+        auto s = Symbol(value).str();
 
         LocalSearchMetaheuristic::Value v;
         if (s == "guided_local_search") {
@@ -175,35 +124,35 @@ void init_routing(Rice::Module& m) {
       })
     .define_method(
       "log_search=",
-      *[](RoutingSearchParameters& self, bool value) {
+      [](RoutingSearchParameters& self, bool value) {
         self.set_log_search(value);
       })
     .define_method(
       "solution_limit=",
-      *[](RoutingSearchParameters& self, int64 value) {
+      [](RoutingSearchParameters& self, int64_t value) {
         self.set_solution_limit(value);
       })
     .define_method(
       "time_limit=",
-      *[](RoutingSearchParameters& self, int64 value) {
+      [](RoutingSearchParameters& self, int64_t value) {
         self.mutable_time_limit()->set_seconds(value);
       })
     .define_method(
       "lns_time_limit=",
-      *[](RoutingSearchParameters& self, int64 value) {
+      [](RoutingSearchParameters& self, int64_t value) {
         self.mutable_lns_time_limit()->set_seconds(value);
       });
 
   Rice::define_class_under<RoutingIndexManager>(m, "RoutingIndexManager")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new_depot",
-      *[](int num_nodes, int num_vehicles, RoutingNodeIndex depot) {
+      [](int num_nodes, int num_vehicles, RoutingNodeIndex depot) {
         return RoutingIndexManager(num_nodes, num_vehicles, depot);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_new_starts_ends",
-      *[](int num_nodes, int num_vehicles, Array starts, Array ends) {
-        return RoutingIndexManager(num_nodes, num_vehicles, nodeIndexVector(starts), nodeIndexVector(ends));
+      [](int num_nodes, int num_vehicles, std::vector<RoutingNodeIndex> starts, std::vector<RoutingNodeIndex> ends) {
+        return RoutingIndexManager(num_nodes, num_vehicles, starts, ends);
       })
     .define_method("index_to_node", &RoutingIndexManager::IndexToNode)
     .define_method("node_to_index", &RoutingIndexManager::NodeToIndex);
@@ -215,29 +164,55 @@ void init_routing(Rice::Module& m) {
     .define_method("max", &Assignment::Max);
 
   // not to be confused with operations_research::sat::IntVar
-  rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "IntVar")
+  rb_cIntVar
+    .define_method("var?", &operations_research::IntVar::IsVar)
+    .define_method("value", &operations_research::IntVar::Value)
+    .define_method("remove_value", &operations_research::IntVar::RemoveValue)
+    .define_method("remove_interval", &operations_research::IntVar::RemoveInterval)
+    .define_method("remove_values", &operations_research::IntVar::RemoveValues)
+    .define_method("set_values", &operations_research::IntVar::SetValues)
+    .define_method("size", &operations_research::IntVar::Size)
+    .define_method("contains", &operations_research::IntVar::Contains)
+    .define_method("old_min", &operations_research::IntVar::OldMin)
+    .define_method("old_max", &operations_research::IntVar::OldMax)
     .define_method(
       "set_range",
-      *[](operations_research::IntVar& self, int64 new_min, int64 new_max) {
+      [](operations_research::IntVar& self, int64_t new_min, int64_t new_max) {
         self.SetRange(new_min, new_max);
       });
 
-  rb_cIntervalVar = Rice::define_class_under<operations_research::IntervalVar>(m, "IntervalVar");
+  Rice::define_class_under<operations_research::IntervalVar>(m, "IntervalVar")
+    .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)
+    .define_method("set_start_max", &operations_research::IntervalVar::SetStartMax)
+    .define_method("set_start_range", &operations_research::IntervalVar::SetStartRange)
+    .define_method("old_start_min", &operations_research::IntervalVar::OldStartMin)
+    .define_method("old_start_max", &operations_research::IntervalVar::OldStartMax)
+    .define_method("end_min", &operations_research::IntervalVar::EndMin)
+    .define_method("end_max", &operations_research::IntervalVar::EndMax)
+    .define_method("set_end_min", &operations_research::IntervalVar::SetEndMin)
+    .define_method("set_end_max", &operations_research::IntervalVar::SetEndMax)
+    .define_method("set_end_range", &operations_research::IntervalVar::SetEndRange)
+    .define_method("old_end_min", &operations_research::IntervalVar::OldEndMin)
+    .define_method("old_end_max", &operations_research::IntervalVar::OldEndMax);
 
-  rb_cRoutingDimension = Rice::define_class_under<RoutingDimension>(m, "RoutingDimension")
+  Rice::define_class_under<RoutingDimension>(m, "RoutingDimension")
     .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient)
     .define_method("cumul_var", &RoutingDimension::CumulVar);
 
-  rb_cConstraint = Rice::define_class_under<operations_research::Constraint>(m, "Constraint");
+  Rice::define_class_under<operations_research::Constraint>(m, "Constraint")
+    .define_method("post", &operations_research::Constraint::Post)
+    .define_method("debug_string", &operations_research::Constraint::DebugString);
 
-  rb_cSolver2 = Rice::define_class_under<operations_research::Solver>(m, "Solver2")
+  Rice::define_class_under<operations_research::Solver>(m, "Solver2")
     .define_method(
       "add",
-      *[](operations_research::Solver& self, Object o) {
+      [](operations_research::Solver& self, Object o) {
         operations_research::Constraint* constraint;
         if (o.respond_to("left")) {
-          operations_research::IntExpr* left(from_ruby<operations_research::IntVar*>(o.call("left")));
-          operations_research::IntExpr* right(from_ruby<operations_research::IntVar*>(o.call("right")));
+          operations_research::IntExpr* left(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("left")));
+          operations_research::IntExpr* right(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("right")));
           auto op = o.call("operator").to_s().str();
           if (op == "==") {
             constraint = self.MakeEquality(left, right);
@@ -247,54 +222,69 @@ void init_routing(Rice::Module& m) {
             throw std::runtime_error("Unknown operator");
           }
         } else {
-          constraint = from_ruby<operations_research::Constraint*>(o);
+          constraint = Rice::detail::From_Ruby<operations_research::Constraint*>().convert(o);
         }
         self.AddConstraint(constraint);
       })
     .define_method(
       "fixed_duration_interval_var",
-      *[](operations_research::Solver& self, operations_research::IntVar* const start_variable, int64 duration, const std::string& name) {
+      [](operations_research::Solver& self, operations_research::IntVar* const start_variable, int64_t duration, const std::string& name) {
         return self.MakeFixedDurationIntervalVar(start_variable, duration, name);
       })
     .define_method(
       "cumulative",
-      *[](operations_research::Solver& self, Array rb_intervals, Array rb_demands, int64 capacity, const std::string& name) {
-        std::vector<operations_research::IntervalVar*> intervals;
-        for (std::size_t i = 0; i < rb_intervals.size(); ++i) {
-          intervals.push_back(from_ruby<operations_research::IntervalVar*>(rb_intervals[i]));
-        }
+      [](operations_research::Solver& self, std::vector<operations_research::IntervalVar*> intervals, std::vector<int64_t> demands, int64_t capacity, const std::string& name) {
+        return self.MakeCumulative(intervals, demands, capacity, name);
+      });
 
-        std::vector<int64> demands;
-        for (std::size_t i = 0; i < rb_demands.size(); ++i) {
-          demands.push_back(from_ruby<int64>(rb_demands[i]));
-        }
+  Rice::define_class_under<ConstraintSolverParameters>(m, "ConstraintSolverParameters")
+    .define_method(
+      "trace_propagation=",
+      [](ConstraintSolverParameters& self, bool value) {
+        self.set_trace_propagation(value);
+      })
+    .define_method(
+      "trace_search=",
+      [](ConstraintSolverParameters& self, bool value) {
+        self.set_trace_search(value);
+      });
 
-        return self.MakeCumulative(intervals, demands, capacity, name);
+  Rice::define_class_under<RoutingModelParameters>(m, "RoutingModelParameters")
+    .define_method(
+      "solver_parameters",
+      [](RoutingModelParameters& self) {
+        return self.mutable_solver_parameters();
       });
 
+  m.define_singleton_function(
+    "default_routing_model_parameters",
+    []() {
+      return operations_research::DefaultRoutingModelParameters();
+    });
+
   Rice::define_class_under<RoutingModel>(m, "RoutingModel")
-    .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager>())
+    .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager, RoutingModelParameters>(), Rice::Arg("index_manager"), Rice::Arg("parameters") = operations_research::DefaultRoutingModelParameters())
     .define_method(
       "register_transit_callback",
-      *[](RoutingModel& self, Object callback) {
+      [](RoutingModel& self, Object callback) {
         return self.RegisterTransitCallback(
-          [callback](int64 from_index, int64 to_index) -> int64 {
-            return from_ruby<int64>(callback.call("call", from_index, to_index));
+          [callback](int64_t from_index, int64_t to_index) -> int64_t {
+            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
           }
         );
       })
     .define_method(
       "register_unary_transit_callback",
-      *[](RoutingModel& self, Object callback) {
+      [](RoutingModel& self, Object callback) {
         return self.RegisterUnaryTransitCallback(
-          [callback](int64 from_index) -> int64 {
-            return from_ruby<int64>(callback.call("call", from_index));
+          [callback](int64_t from_index) -> int64_t {
+            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
           }
         );
       })
     .define_method("depot", &RoutingModel::GetDepot)
     .define_method("size", &RoutingModel::Size)
-    .define_method("status", *[](RoutingModel& self) {
+    .define_method("status", [](RoutingModel& self) {
         auto status = self.status();
 
         if (status == RoutingModel::ROUTING_NOT_SOLVED) {
@@ -320,29 +310,17 @@ void init_routing(Rice::Module& m) {
     .define_method("add_dimension", &RoutingModel::AddDimension)
     .define_method(
       "add_dimension_with_vehicle_capacity",
-      *[](RoutingModel& self, int evaluator_index, int64 slack_max, Array vc, bool fix_start_cumul_to_zero, const std::string& name) {
-        std::vector<int64> vehicle_capacities;
-        for (std::size_t i = 0; i < vc.size(); ++i) {
-          vehicle_capacities.push_back(from_ruby<int64>(vc[i]));
-        }
+      [](RoutingModel& self, int evaluator_index, int64_t slack_max, std::vector<int64_t> vehicle_capacities, bool fix_start_cumul_to_zero, const std::string& name) {
         self.AddDimensionWithVehicleCapacity(evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name);
       })
     .define_method(
       "add_dimension_with_vehicle_transits",
-      *[](RoutingModel& self, Array rb_indices, int64 slack_max, int64 capacity, bool fix_start_cumul_to_zero, const std::string& name) {
-        std::vector<int> evaluator_indices;
-        for (std::size_t i = 0; i < rb_indices.size(); ++i) {
-          evaluator_indices.push_back(from_ruby<int>(rb_indices[i]));
-        }
+      [](RoutingModel& self, std::vector<int> evaluator_indices, int64_t slack_max, int64_t capacity, bool fix_start_cumul_to_zero, const std::string& name) {
         self.AddDimensionWithVehicleTransits(evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name);
       })
     .define_method(
       "add_disjunction",
-      *[](RoutingModel& self, Array rb_indices, int64 penalty) {
-        std::vector<int64> indices;
-        for (std::size_t i = 0; i < rb_indices.size(); ++i) {
-          indices.push_back(from_ruby<int64>(rb_indices[i]));
-        }
+      [](RoutingModel& self, std::vector<int64_t> indices, int64_t penalty) {
         self.AddDisjunction(indices, penalty);
       })
     .define_method("add_pickup_and_delivery", &RoutingModel::AddPickupAndDelivery)
@@ -360,9 +338,7 @@ void init_routing(Rice::Module& m) {
     .define_method("add_variable_minimized_by_finalizer", &RoutingModel::AddVariableMinimizedByFinalizer)
     .define_method(
       "solve_with_parameters",
-      *[](RoutingModel& self, const RoutingSearchParameters& search_parameters) {
-        auto assignment = self.SolveWithParameters(search_parameters);
-        // std::cout << assignment->DebugString();
-        return (Assignment) assignment;
+      [](RoutingModel& self, const RoutingSearchParameters& search_parameters) {
+        return self.SolveWithParameters(search_parameters);
       });
 }