or-tools 0.1.2 → 0.3.0

data/ext/or-tools/ext.cpp

@@ -115,14 +115,22 @@ operations_research::sat::LinearExpr from_ruby
       auto cvar = (Array) var;
       // TODO clean up
       Object o = cvar[0];
-      if (((Rice::String) o.call("class").call("name")).str() == "ORTools::BoolVar") {
-        expr.AddVar(from_ruby<operations_research::sat::BoolVar>(cvar[0]));
+      std::string type = ((String) o.call("class").call("name")).str();
+      if (type == "ORTools::BoolVar") {
+        expr.AddTerm(from_ruby<operations_research::sat::BoolVar>(cvar[0]), from_ruby<int64>(cvar[1]));
+      } else if (type == "Integer") {
+        expr.AddConstant(from_ruby<int64>(cvar[0]));
       } else {
         expr.AddTerm(from_ruby<operations_research::sat::IntVar>(cvar[0]), from_ruby<int64>(cvar[1]));
       }
     }
   } else {
-    expr = from_ruby<operations_research::sat::IntVar>(x);
+    std::string type = ((String) x.call("class").call("name")).str();
+    if (type == "ORTools::BoolVar") {
+      expr = from_ruby<operations_research::sat::BoolVar>(x);
+    } else {
+      expr = from_ruby<operations_research::sat::IntVar>(x);
+    }
   }
 
   return expr;
@@ -141,13 +149,22 @@ class Assignment {
     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);
+    }
 };
 
 Class rb_cMPVariable;
 Class rb_cMPConstraint;
 Class rb_cMPObjective;
 Class rb_cIntVar;
+Class rb_cIntervalVar;
 Class rb_cRoutingDimension;
+Class rb_cConstraint;
+Class rb_cSolver2;
 
 template<>
 inline
@@ -177,6 +194,13 @@ Object to_ruby(operations_research::IntVar* const
   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)
@@ -184,6 +208,86 @@ Object to_ruby(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);
+}
+
+// need a wrapper class since absl::Span doesn't own
+class IntVarSpan {
+  std::vector<operations_research::sat::IntVar> vec;
+  public:
+    IntVarSpan(Object x) {
+      Array a = Array(x);
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<operations_research::sat::IntVar>(a[i]));
+      }
+    }
+    operator absl::Span<const operations_research::sat::IntVar>() {
+      return absl::Span<const operations_research::sat::IntVar>(vec);
+    }
+};
+
+template<>
+inline
+IntVarSpan from_ruby<IntVarSpan>(Object x)
+{
+  return IntVarSpan(x);
+}
+
+// need a wrapper class since absl::Span doesn't own
+class IntervalVarSpan {
+  std::vector<operations_research::sat::IntervalVar> vec;
+  public:
+    IntervalVarSpan(Object x) {
+      Array a = Array(x);
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<operations_research::sat::IntervalVar>(a[i]));
+      }
+    }
+    operator absl::Span<const operations_research::sat::IntervalVar>() {
+      return absl::Span<const operations_research::sat::IntervalVar>(vec);
+    }
+};
+
+template<>
+inline
+IntervalVarSpan from_ruby<IntervalVarSpan>(Object x)
+{
+  return IntervalVarSpan(x);
+}
+
+// need a wrapper class since absl::Span doesn't own
+class BoolVarSpan {
+  std::vector<operations_research::sat::BoolVar> vec;
+  public:
+    BoolVarSpan(Object x) {
+      Array a = Array(x);
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<operations_research::sat::BoolVar>(a[i]));
+      }
+    }
+    operator absl::Span<const operations_research::sat::BoolVar>() {
+      return absl::Span<const operations_research::sat::BoolVar>(vec);
+    }
+};
+
+template<>
+inline
+BoolVarSpan from_ruby<BoolVarSpan>(Object x)
+{
+  return BoolVarSpan(x);
+}
+
 extern "C"
 void Init_ext()
 {
@@ -283,16 +387,26 @@ void Init_ext()
     .define_method("solution_value", &MPVariable::solution_value)
     .define_method(
       "+",
-      *[](MPVariable& self, MPVariable& other) {
+      *[](MPVariable& self, LinearExpr& other) {
         LinearExpr s(&self);
-        LinearExpr o(&other);
-        return s + o;
+        return s + other;
+      })
+    .define_method(
+      "-",
+      *[](MPVariable& self, LinearExpr& other) {
+        LinearExpr s(&self);
+        return s - other;
       })
     .define_method(
       "*",
       *[](MPVariable& self, double other) {
         LinearExpr s(&self);
         return s * other;
+      })
+    .define_method(
+      "inspect",
+      *[](MPVariable& self) {
+        return "#<ORTools::MPVariable @name=\"" + self.name() + "\">";
       });
 
   define_class_under<LinearExpr>(rb_mORTools, "LinearExpr")
@@ -308,6 +422,17 @@ void Init_ext()
         LinearExpr o(&other);
         return self + o;
       })
+    .define_method(
+      "_gte_double",
+      *[](LinearExpr& self, double other) {
+        LinearExpr o(other);
+        return self >= o;
+      })
+    .define_method(
+      "_gte_linear_expr",
+      *[](LinearExpr& self, LinearExpr& other) {
+        return self >= other;
+      })
     .define_method(
       "_lte_double",
       *[](LinearExpr& self, double other) {
@@ -362,6 +487,11 @@ void Init_ext()
     .define_method("iterations", &MPSolver::iterations)
     .define_method("nodes", &MPSolver::nodes)
     .define_method("objective", &MPSolver::MutableObjective)
+    .define_method(
+      "maximize",
+      *[](MPSolver& self, LinearExpr& expr) {
+        return self.MutableObjective()->MaximizeLinearExpr(expr);
+      })
     .define_method(
       "minimize",
       *[](MPSolver& self, LinearExpr& expr) {
@@ -401,11 +531,18 @@ void Init_ext()
         }
       });
 
-  // not to be confused with operations_research::IntVar
-  define_class_under<operations_research::sat::IntVar>(rb_mORTools, "SatIntVar");
+  define_class_under<operations_research::sat::IntVar>(rb_mORTools, "SatIntVar")
+    .define_method("name", &operations_research::sat::IntVar::Name);
+
+  define_class_under<operations_research::sat::IntervalVar>(rb_mORTools, "SatIntervalVar")
+    .define_method("name", &operations_research::sat::IntervalVar::Name);
+
+  define_class_under<operations_research::sat::Constraint>(rb_mORTools, "SatConstraint");
+
   define_class_under<BoolVar>(rb_mORTools, "BoolVar")
     .define_method("name", &BoolVar::Name)
     .define_method("index", &BoolVar::index)
+    .define_method("not", &BoolVar::Not)
     .define_method(
       "inspect",
       *[](BoolVar& self) {
@@ -426,6 +563,11 @@ void Init_ext()
       *[](CpModelBuilder& self, std::string name) {
         return self.NewBoolVar().WithName(name);
       })
+    .define_method(
+      "new_interval_var",
+      *[](CpModelBuilder& self, operations_research::sat::IntVar start, operations_research::sat::IntVar size, operations_research::sat::IntVar end, std::string name) {
+        return self.NewIntervalVar(start, size, end).WithName(name);
+      })
     .define_method(
       "add_equality",
       *[](CpModelBuilder& self, operations_research::sat::LinearExpr x, operations_research::sat::LinearExpr y) {
@@ -456,6 +598,27 @@ void Init_ext()
       *[](CpModelBuilder& self, operations_research::sat::LinearExpr x, operations_research::sat::LinearExpr y) {
         self.AddLessOrEqual(x, y);
       })
+    .define_method(
+      "add_all_different",
+      *[](CpModelBuilder& self, IntVarSpan vars) {
+        self.AddAllDifferent(vars);
+      })
+    .define_method(
+      "add_max_equality",
+      *[](CpModelBuilder& self, operations_research::sat::IntVar target, IntVarSpan vars) {
+        self.AddMaxEquality(target, vars);
+      })
+    .define_method(
+      "add_no_overlap",
+      *[](CpModelBuilder& self, IntervalVarSpan vars) {
+        self.AddNoOverlap(vars);
+      })
+    .define_method(
+      "add_bool_or",
+      *[](CpModelBuilder& self, BoolVarSpan literals) {
+        self.AddBoolOr(literals);
+      })
+    .define_method("add_implication", &CpModelBuilder::AddImplication)
     .define_method(
       "maximize",
       *[](CpModelBuilder& self, operations_research::sat::LinearExpr expr) {
@@ -470,13 +633,15 @@ void Init_ext()
   define_class_under(rb_mORTools, "CpSolver")
     .define_method(
       "_solve_with_observer",
-      *[](Object self, CpModelBuilder& model, Object callback) {
+      *[](Object self, CpModelBuilder& model, Object callback, bool all_solutions) {
         operations_research::sat::Model m;
 
-        // set parameters for SearchForAllSolutions
-        SatParameters parameters;
-        parameters.set_enumerate_all_solutions(true);
-        m.Add(NewSatParameters(parameters));
+        if (all_solutions) {
+          // set parameters for SearchForAllSolutions
+          SatParameters parameters;
+          parameters.set_enumerate_all_solutions(true);
+          m.Add(NewSatParameters(parameters));
+        }
 
         m.Add(NewFeasibleSolutionObserver(
           [callback](const CpSolverResponse& r) {
@@ -496,6 +661,11 @@ void Init_ext()
       "_solution_integer_value",
       *[](Object self, CpSolverResponse& response, operations_research::sat::IntVar& x) {
         return SolutionIntegerValue(response, x);
+      })
+    .define_method(
+      "_solution_boolean_value",
+      *[](Object self, CpSolverResponse& response, operations_research::sat::BoolVar& x) {
+        return SolutionBooleanValue(response, x);
       });
 
   define_class_under<CpSolverResponse>(rb_mORTools, "CpSolverResponse")
@@ -503,7 +673,12 @@ void Init_ext()
     .define_method("num_conflicts", &CpSolverResponse::num_conflicts)
     .define_method("num_branches", &CpSolverResponse::num_branches)
     .define_method("wall_time", &CpSolverResponse::wall_time)
-    // .define_method("solution_integer_value", &SolutionIntegerValue)
+    .define_method(
+      "solution_integer_value",
+      *[](CpSolverResponse& self, operations_research::sat::IntVar& x) {
+        operations_research::sat::LinearExpr expr(x);
+        return SolutionIntegerValue(self, expr);
+      })
     .define_method("solution_boolean_value", &operations_research::sat::SolutionBooleanValue)
     .define_method(
       "status",
@@ -525,17 +700,72 @@ void Init_ext()
 
   define_class_under<RoutingIndexManager>(rb_mORTools, "RoutingIndexManager")
     .define_constructor(Constructor<RoutingIndexManager, int, int, RoutingNodeIndex>())
-    .define_method("index_to_node", &RoutingIndexManager::IndexToNode);
+    .define_method("index_to_node", &RoutingIndexManager::IndexToNode)
+    .define_method("node_to_index", &RoutingIndexManager::NodeToIndex);
 
   define_class_under<Assignment>(rb_mORTools, "Assignment")
     .define_method("objective_value", &Assignment::ObjectiveValue)
-    .define_method("value", &Assignment::Value);
+    .define_method("value", &Assignment::Value)
+    .define_method("min", &Assignment::Min)
+    .define_method("max", &Assignment::Max);
 
   // not to be confused with operations_research::sat::IntVar
-  rb_cIntVar = define_class_under<operations_research::IntVar>(rb_mORTools, "IntVar");
+  rb_cIntVar = define_class_under<operations_research::IntVar>(rb_mORTools, "IntVar")
+    .define_method(
+      "set_range",
+      *[](operations_research::IntVar& self, int64 new_min, int64 new_max) {
+        self.SetRange(new_min, new_max);
+      });
+
+  rb_cIntervalVar = define_class_under<operations_research::IntervalVar>(rb_mORTools, "IntervalVar");
 
   rb_cRoutingDimension = define_class_under<RoutingDimension>(rb_mORTools, "RoutingDimension")
-    .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient);
+    .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient)
+    .define_method("cumul_var", &RoutingDimension::CumulVar);
+
+  rb_cConstraint = define_class_under<operations_research::Constraint>(rb_mORTools, "Constraint");
+
+  rb_cSolver2 = define_class_under<operations_research::Solver>(rb_mORTools, "Solver2")
+    .define_method(
+      "add",
+      *[](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")));
+          auto op = o.call("operator").to_s().str();
+          if (op == "==") {
+            constraint = self.MakeEquality(left, right);
+          } else if (op == "<=") {
+            constraint = self.MakeLessOrEqual(left, right);
+          } else {
+            throw std::runtime_error("Unknown operator");
+          }
+        } else {
+          constraint = from_ruby<operations_research::Constraint*>(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) {
+        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]));
+        }
+
+        std::vector<int64> demands;
+        for (std::size_t i = 0; i < rb_demands.size(); ++i) {
+          demands.push_back(from_ruby<int64>(rb_demands[i]));
+        }
+
+        return self.MakeCumulative(intervals, demands, capacity, name);
+      });
 
   define_class_under<RoutingModel>(rb_mORTools, "RoutingModel")
     .define_constructor(Constructor<RoutingModel, RoutingIndexManager>())
@@ -548,13 +778,44 @@ void Init_ext()
           }
         );
       })
+    .define_method(
+      "register_unary_transit_callback",
+      *[](RoutingModel& self, Object callback) {
+        return self.RegisterUnaryTransitCallback(
+          [callback](int64 from_index) -> int64 {
+            return from_ruby<int64>(callback.call("call", from_index));
+          }
+        );
+      })
     .define_method("depot", &RoutingModel::GetDepot)
+    .define_method("size", &RoutingModel::Size)
+    .define_method("vehicle_var", &RoutingModel::VehicleVar)
     .define_method("set_arc_cost_evaluator_of_all_vehicles", &RoutingModel::SetArcCostEvaluatorOfAllVehicles)
     .define_method("set_arc_cost_evaluator_of_vehicle", &RoutingModel::SetArcCostEvaluatorOfVehicle)
     .define_method("set_fixed_cost_of_all_vehicles", &RoutingModel::SetFixedCostOfAllVehicles)
     .define_method("set_fixed_cost_of_vehicle", &RoutingModel::SetFixedCostOfVehicle)
     .define_method("fixed_cost_of_vehicle", &RoutingModel::GetFixedCostOfVehicle)
     .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]));
+        }
+        self.AddDimensionWithVehicleCapacity(evaluator_index, slack_max, vehicle_capacities, 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]));
+        }
+        self.AddDisjunction(indices, penalty);
+      })
+    .define_method("add_pickup_and_delivery", &RoutingModel::AddPickupAndDelivery)
+    .define_method("solver", &RoutingModel::solver)
     .define_method("start", &RoutingModel::Start)
     .define_method("end", &RoutingModel::End)
     .define_method("start?", &RoutingModel::IsStart)
@@ -565,6 +826,7 @@ void Init_ext()
     .define_method("next_var", &RoutingModel::NextVar)
     .define_method("arc_cost_for_vehicle", &RoutingModel::GetArcCostForVehicle)
     .define_method("mutable_dimension", &RoutingModel::GetMutableDimension)
+    .define_method("add_variable_minimized_by_finalizer", &RoutingModel::AddVariableMinimizedByFinalizer)
     .define_method(
       "solve_with_parameters",
       *[](RoutingModel& self, const RoutingSearchParameters& search_parameters) {

data/ext/or-tools/extconf.rb

@@ -1,6 +1,6 @@
 require "mkmf-rice"
 
-abort "Missing stdc++" unless have_library("stdc++")
+raise "Missing stdc++" unless have_library("stdc++")
 
 $CXXFLAGS << " -std=c++11 -DUSE_CBC"
 
@@ -8,73 +8,31 @@ $CXXFLAGS << " -std=c++11 -DUSE_CBC"
 $CXXFLAGS << " -Wno-sign-compare -Wno-shorten-64-to-32 -Wno-ignored-qualifiers"
 
 inc, lib = dir_config("or-tools")
-
-inc ||= "/usr/local/include"
-lib ||= "/usr/local/lib"
+if inc || lib
+  inc ||= "/usr/local/include"
+  lib ||= "/usr/local/lib"
+  rpath = lib
+else
+  # download
+  require_relative "vendor"
+
+  inc = "#{$vendor_path}/include"
+  lib = "#{$vendor_path}/lib"
+
+  # make rpath relative
+  # use double dollar sign and single quotes to escape properly
+  rpath_prefix = RbConfig::CONFIG["host_os"] =~ /darwin/ ? "@loader_path" : "$$ORIGIN"
+  rpath = "'#{rpath_prefix}/../../tmp/or-tools/lib'"
+end
 
 $INCFLAGS << " -I#{inc}"
 
-$LDFLAGS << " -Wl,-rpath,#{lib}"
+$LDFLAGS << " -Wl,-rpath,#{rpath}"
 $LDFLAGS << " -L#{lib}"
-$LDFLAGS << " -lortools"
+raise "OR-Tools not found" unless have_library("ortools")
 
-%w(
-  absl_city
-  absl_time_zone
-  absl_spinlock_wait
-  absl_log_severity
-  absl_failure_signal_handler
-  absl_bad_optional_access
-  absl_hash
-  absl_raw_logging_internal
-  absl_random_internal_pool_urbg
-  absl_base
-  absl_bad_any_cast_impl
-  absl_periodic_sampler
-  absl_random_distributions
-  absl_flags_usage_internal
-  absl_random_seed_sequences
-  absl_throw_delegate
-  absl_flags_handle
-  absl_dynamic_annotations
-  absl_debugging_internal
-  absl_strings
-  absl_flags
-  absl_malloc_internal
-  absl_str_format_internal
-  absl_flags_usage
-  absl_strings_internal
-  absl_flags_program_name
-  absl_flags_registry
-  absl_int128
-  absl_scoped_set_env
-  absl_raw_hash_set
-  absl_random_internal_seed_material
-  absl_symbolize
-  absl_random_internal_randen_slow
-  absl_graphcycles_internal
-  absl_exponential_biased
-  absl_random_internal_randen_hwaes_impl
-  absl_bad_variant_access
-  absl_stacktrace
-  absl_random_internal_randen_hwaes
-  absl_flags_parse
-  absl_random_internal_randen
-  absl_random_internal_distribution_test_util
-  absl_time
-  absl_flags_config
-  absl_synchronization
-  absl_hashtablez_sampler
-  absl_demangle_internal
-  absl_leak_check
-  absl_flags_marshalling
-  absl_leak_check_disable
-  absl_examine_stack
-  absl_flags_internal
-  absl_random_seed_gen_exception
-  absl_civil_time
-).each do |lib|
-  $LDFLAGS << " -l#{lib}"
+Dir["#{lib}/libabsl_*.a"].each do |lib|
+  $LDFLAGS << " #{lib}"
 end
 
 create_makefile("or_tools/ext")