or-tools 0.4.3 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a1064c39ae0b5431b303db41b4fe03da7f80d26beeab576b33b85fe47dee4d8
-  data.tar.gz: 5819ef15c9ec8b1b507fb4e4596397a8f2e562fa72de6580b1e78188a404a3db
+  metadata.gz: 405e26b51140e6605acd8904d7e90e0e7f48b7cfd83641fef6e2e737e7b8cda4
+  data.tar.gz: e6e0506979a829c260f8bae70e7769524d59d83b7a52e1cadfb6e553d8116587
 SHA512:
-  metadata.gz: 797f8fdba98a3843f3da03acdee070445e6f4a37650936a700ebab3af58bc779cd57c44b3b68341f28203beb986e6818a884d65588fa14264d0eb89463183d2e
-  data.tar.gz: acd539cc1f14467ddd2edfaa65723590a216c709aa3085d2257472600e023e7757109eeade70f995131f26f9769250807c998d0d5e30d8ce51af90536063cf3b
+  metadata.gz: 237e13e7340682d974602743de724031c28c99add58c4cf49e670bb05f4fa0c691dcf00dd75797a9ab3efcc9b5505a96f3a2a3d542db8c8746652ec114b5a258
+  data.tar.gz: 5c782dd281122001095663da47fce8279f5a2c29b6eed65e2288df6727c55724ef424d4c3bfda3ed3b4ce53493964b88d64f67fc843e97dafd98f3e21a4c5183

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.5.0 (2021-04-30)
+
+- Updated OR-Tools to 9.0
+- Added binary installation for CentOS 7
+- Added `sufficient_assumptions_for_infeasibility` to `CpSolver`
+
 ## 0.4.3 (2021-03-26)
 
 - Added `add_assumption`, `add_assumptions`, and `clear_assumptions` to `CpModel`

data/ext/or-tools/bin_packing.cpp

@@ -30,24 +30,24 @@ void init_bin_packing(Rice::Module& m) {
     .define_method(
       "init",
       *[](KnapsackSolver& self, Array rb_values, Array rb_weights, Array rb_capacities) {
-        std::vector<int64> values;
+        std::vector<int64_t> values;
         for (std::size_t i = 0; i < rb_values.size(); ++i) {
-          values.push_back(from_ruby<int64>(rb_values[i]));
+          values.push_back(from_ruby<int64_t>(rb_values[i]));
         }
 
-        std::vector<std::vector<int64>> weights;
+        std::vector<std::vector<int64_t>> weights;
         for (std::size_t i = 0; i < rb_weights.size(); ++i) {
           Array rb_w = Array(rb_weights[i]);
-          std::vector<int64> w;
+          std::vector<int64_t> w;
           for (std::size_t j = 0; j < rb_w.size(); ++j) {
-            w.push_back(from_ruby<int64>(rb_w[j]));
+            w.push_back(from_ruby<int64_t>(rb_w[j]));
           }
           weights.push_back(w);
         }
 
-        std::vector<int64> capacities;
+        std::vector<int64_t> capacities;
         for (std::size_t i = 0; i < rb_capacities.size(); ++i) {
-          capacities.push_back(from_ruby<int64>(rb_capacities[i]));
+          capacities.push_back(from_ruby<int64_t>(rb_capacities[i]));
         }
 
         self.Init(values, weights, capacities);

data/ext/or-tools/constraint.cpp

@@ -20,10 +20,14 @@ using operations_research::sat::SolutionBooleanValue;
 using operations_research::sat::SolutionIntegerValue;
 
 using Rice::Array;
+using Rice::Class;
 using Rice::Object;
 using Rice::String;
 using Rice::Symbol;
 
+Class rb_cBoolVar;
+Class rb_cSatIntVar;
+
 template<>
 inline
 LinearExpr from_ruby<LinearExpr>(Object x)
@@ -31,29 +35,24 @@ LinearExpr from_ruby<LinearExpr>(Object x)
   LinearExpr expr;
 
   if (x.respond_to("to_i")) {
-    expr = from_ruby<int64>(x.call("to_i"));
+    expr = from_ruby<int64_t>(x.call("to_i"));
   } else if (x.respond_to("vars")) {
     Array vars = x.call("vars");
-    for(auto const& var: vars) {
+    for (auto const& var: vars) {
       auto cvar = (Array) var;
-      // TODO clean up
       Object o = cvar[0];
-      std::string type = ((String) o.call("class").call("name")).str();
-      if (type == "ORTools::BoolVar") {
-        expr.AddTerm(from_ruby<BoolVar>(cvar[0]), from_ruby<int64>(cvar[1]));
-      } else if (type == "Integer") {
-        expr.AddConstant(from_ruby<int64>(cvar[0]) * from_ruby<int64>(cvar[1]));
+      if (o.is_a(rb_cBoolVar)) {
+        expr.AddTerm(from_ruby<BoolVar>(cvar[0]), from_ruby<int64_t>(cvar[1]));
+      } else if (o.is_a(rb_cInteger)) {
+        expr.AddConstant(from_ruby<int64_t>(cvar[0]) * from_ruby<int64_t>(cvar[1]));
       } else {
-        expr.AddTerm(from_ruby<IntVar>(cvar[0]), from_ruby<int64>(cvar[1]));
+        expr.AddTerm(from_ruby<IntVar>(cvar[0]), from_ruby<int64_t>(cvar[1]));
       }
     }
+  } else if (x.is_a(rb_cBoolVar)) {
+    expr = from_ruby<BoolVar>(x);
   } else {
-    std::string type = ((String) x.call("class").call("name")).str();
-    if (type == "ORTools::BoolVar") {
-      expr = from_ruby<BoolVar>(x);
-    } else {
-      expr = from_ruby<IntVar>(x);
-    }
+    expr = from_ruby<IntVar>(x);
   }
 
   return expr;
@@ -128,8 +127,6 @@ LinearExprSpan from_ruby<LinearExprSpan>(Object x)
   return LinearExprSpan(x);
 }
 
-Rice::Class rb_cSatIntVar;
-
 // need a wrapper class since absl::Span doesn't own
 class BoolVarSpan {
   std::vector<BoolVar> vec;
@@ -178,7 +175,7 @@ void init_constraint(Rice::Module& m) {
         }
       });
 
-  Rice::define_class_under<BoolVar>(m, "BoolVar")
+  rb_cBoolVar = Rice::define_class_under<BoolVar>(m, "BoolVar")
     .define_method("name", &BoolVar::Name)
     .define_method("index", &BoolVar::index)
     .define_method("not", &BoolVar::Not)
@@ -200,7 +197,7 @@ void init_constraint(Rice::Module& m) {
     .define_constructor(Rice::Constructor<CpModelBuilder>())
     .define_method(
       "new_int_var",
-      *[](CpModelBuilder& self, int64 start, int64 end, const std::string& name) {
+      *[](CpModelBuilder& self, int64_t start, int64_t end, const std::string& name) {
         const operations_research::Domain domain(start, end);
         return self.NewIntVar(domain).WithName(name);
       })
@@ -211,7 +208,7 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "new_constant",
-      *[](CpModelBuilder& self, int64 value) {
+      *[](CpModelBuilder& self, int64_t value) {
         return self.NewConstant(value);
       })
     .define_method(
@@ -362,7 +359,7 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "add_hint",
-      *[](CpModelBuilder& self, IntVar var, int64 value) {
+      *[](CpModelBuilder& self, IntVar var, int64_t value) {
         self.AddHint(var, value);
       })
     .define_method(
@@ -462,5 +459,15 @@ void init_constraint(Rice::Module& m) {
         } else {
           throw std::runtime_error("Unknown solver status");
         }
+      })
+    .define_method(
+      "sufficient_assumptions_for_infeasibility",
+      *[](CpSolverResponse& self) {
+        auto a = Array();
+        auto assumptions = self.sufficient_assumptions_for_infeasibility();
+        for (auto const& v : assumptions) {
+          a.push(v);
+        }
+        return a;
       });
 }

data/ext/or-tools/network_flows.cpp

@@ -47,7 +47,7 @@ void init_network_flows(Rice::Module& m) {
         self.GetSourceSideMinCut(&result);
 
         Array ret;
-        for(auto const& it: result) {
+        for (auto const& it: result) {
           ret.push(it);
         }
         return ret;
@@ -59,7 +59,7 @@ void init_network_flows(Rice::Module& m) {
         self.GetSinkSideMinCut(&result);
 
         Array ret;
-        for(auto const& it: result) {
+        for (auto const& it: result) {
           ret.push(it);
         }
         return ret;

data/ext/or-tools/routing.cpp

@@ -54,16 +54,16 @@ class Assignment {
     Assignment(const operations_research::Assignment* v) {
       self = v;
     }
-    int64 ObjectiveValue() {
+    int64_t ObjectiveValue() {
       return self->ObjectiveValue();
     }
-    int64 Value(const operations_research::IntVar* const var) const {
+    int64_t Value(const operations_research::IntVar* const var) const {
       return self->Value(var);
     }
-    int64 Min(const operations_research::IntVar* const var) const {
+    int64_t Min(const operations_research::IntVar* const var) const {
       return self->Min(var);
     }
-    int64 Max(const operations_research::IntVar* const var) const {
+    int64_t Max(const operations_research::IntVar* const var) const {
       return self->Max(var);
     }
 };
@@ -180,17 +180,17 @@ void init_routing(Rice::Module& m) {
       })
     .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);
       });
 
@@ -218,7 +218,7 @@ void init_routing(Rice::Module& m) {
   rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "IntVar")
     .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);
       });
 
@@ -253,20 +253,20 @@ void init_routing(Rice::Module& m) {
       })
     .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) {
+      *[](operations_research::Solver& self, Array rb_intervals, Array rb_demands, int64_t 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;
+        std::vector<int64_t> demands;
         for (std::size_t i = 0; i < rb_demands.size(); ++i) {
-          demands.push_back(from_ruby<int64>(rb_demands[i]));
+          demands.push_back(from_ruby<int64_t>(rb_demands[i]));
         }
 
         return self.MakeCumulative(intervals, demands, capacity, name);
@@ -278,8 +278,8 @@ void init_routing(Rice::Module& m) {
       "register_transit_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 from_ruby<int64_t>(callback.call("call", from_index, to_index));
           }
         );
       })
@@ -287,8 +287,8 @@ void init_routing(Rice::Module& m) {
       "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));
+          [callback](int64_t from_index) -> int64_t {
+            return from_ruby<int64_t>(callback.call("call", from_index));
           }
         );
       })
@@ -320,16 +320,16 @@ 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;
+      *[](RoutingModel& self, int evaluator_index, int64_t slack_max, Array vc, bool fix_start_cumul_to_zero, const std::string& name) {
+        std::vector<int64_t> vehicle_capacities;
         for (std::size_t i = 0; i < vc.size(); ++i) {
-          vehicle_capacities.push_back(from_ruby<int64>(vc[i]));
+          vehicle_capacities.push_back(from_ruby<int64_t>(vc[i]));
         }
         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) {
+      *[](RoutingModel& self, Array rb_indices, int64_t slack_max, int64_t 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]));
@@ -338,10 +338,10 @@ void init_routing(Rice::Module& m) {
       })
     .define_method(
       "add_disjunction",
-      *[](RoutingModel& self, Array rb_indices, int64 penalty) {
-        std::vector<int64> indices;
+      *[](RoutingModel& self, Array rb_indices, int64_t penalty) {
+        std::vector<int64_t> indices;
         for (std::size_t i = 0; i < rb_indices.size(); ++i) {
-          indices.push_back(from_ruby<int64>(rb_indices[i]));
+          indices.push_back(from_ruby<int64_t>(rb_indices[i]));
         }
         self.AddDisjunction(indices, penalty);
       })

data/ext/or-tools/vendor.rb

@@ -3,26 +3,29 @@ require "fileutils"
 require "net/http"
 require "tmpdir"
 
-version = "8.2.8710"
+version = "9.0.9048"
 
 if RbConfig::CONFIG["host_os"] =~ /darwin/i
-  filename = "or-tools_MacOsX-11.2.1_v#{version}.tar.gz"
-  checksum = "1c3bd45ab10677aa96d404cb837067e786a6d98123d8b556cf29d6994aa43b3b"
+  filename = "or-tools_MacOsX-11.2.3_v#{version}.tar.gz"
+  checksum = "adf73a00d4ec49558b67be5ce3cfc8f30268da2253b35feb11d0d40700550bf6"
 else
   os = %x[lsb_release -is].chomp rescue nil
   os_version = %x[lsb_release -rs].chomp rescue nil
   if os == "Ubuntu" && os_version == "20.04"
     filename = "or-tools_ubuntu-20.04_v#{version}.tar.gz"
-    checksum = "ab3b3051b10a4bbe8d080857f3c4ef3cfe9c10896ff94f352bb779e993756dd7"
+    checksum = "5565343c1c310d2885a40ce850ae7e3468299b3fee97ae8eed8425ce06bd4960"
   elsif os == "Ubuntu" && os_version == "18.04"
     filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
-    checksum = "0d052deb2ba4491c29e86242fb5d61d0fe14bac847c2feaa35fbeff925ea40a0"
+    checksum = "08cf548d0179f7fa814bb7458be94cd1b8a3de14985e6a9faf6118a1d8571539"
   elsif os == "Debian" && os_version == "10"
     filename = "or-tools_debian-10_v#{version}.tar.gz"
-    checksum = "1f2ec99181c92859ab46e68a6231babce92ded949fd1d08ee31afa4db04c43b3"
+    checksum = "063fb1d8765ae23b0bb25b9c561e904532713416fe0458f7db45a0f72190eb50"
   elsif os == "CentOS" && os_version == "8"
     filename = "or-tools_centos-8_v#{version}.tar.gz"
-    checksum = "be638a20b36f6da81aa29fd24c69c4a66afc980b8a221b1cbabb3910b9827718"
+    checksum = "c98212ed4fc699d8ae70c1f53cd1d8dacd28e52970336fab5b86dedf7406f215"
+  elsif os == "CentOS" && os_version == "7"
+    filename = "or-tools_centos-7_v#{version}.tar.gz"
+    checksum = "b992bda4614bbc703583b0e9edcd2ade54bacfb9909399b20c8aa95ff7197d68"
   else
     platform =
       if Gem.win_platform?

data/lib/or_tools/cp_solver.rb

@@ -29,6 +29,10 @@ module ORTools
       @response.status
     end
 
+    def sufficient_assumptions_for_infeasibility
+      @response.sufficient_assumptions_for_infeasibility
+    end
+
     def parameters
       @parameters ||= SatParameters.new
     end

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.4.3"
+  VERSION = "0.5.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.5.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-26 00:00:00.000000000 Z
+date: 2021-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice