or-tools 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 187c4661b540b302b0b61fe7925c841342044906602a565d11855bbc0d407510
-  data.tar.gz: ad2ac0aa8f426ff09144c5194ec5f278cf3ec8178dfe270c6b853a6795bb3447
+  metadata.gz: 7a1064c39ae0b5431b303db41b4fe03da7f80d26beeab576b33b85fe47dee4d8
+  data.tar.gz: 5819ef15c9ec8b1b507fb4e4596397a8f2e562fa72de6580b1e78188a404a3db
 SHA512:
-  metadata.gz: 98764f3d32b697cca083f3f521b109f070fe760123ebaff0926e4729fbe161d95e264ec19313da114b3801fe8f0a8cf8ad7fff31ed2e87b5422d90235b78f508
-  data.tar.gz: d299fe041dfaa8a54bbe879beb079e1bb19fe36d2453805562cae95be5ffe7ddf292cf07a305d0aaa760cab0d80506923f90714df17fc96c1dde05f8afd55241
+  metadata.gz: 797f8fdba98a3843f3da03acdee070445e6f4a37650936a700ebab3af58bc779cd57c44b3b68341f28203beb986e6818a884d65588fa14264d0eb89463183d2e
+  data.tar.gz: acd539cc1f14467ddd2edfaa65723590a216c709aa3085d2257472600e023e7757109eeade70f995131f26f9769250807c998d0d5e30d8ce51af90536063cf3b

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+## 0.4.3 (2021-03-26)
+
+- Added `add_assumption`, `add_assumptions`, and `clear_assumptions` to `CpModel`
+- Added `add_hint` and `clear_hints` to `CpModel`
+- Added `only_enforce_if` to `SatConstraint`
+- Fixed installation for Debian
+
 ## 0.4.2 (2021-03-03)
 
 - Updated OR-Tools to 8.2

data/ext/or-tools/constraint.cpp

@@ -128,6 +128,8 @@ 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;
@@ -136,7 +138,11 @@ class BoolVarSpan {
       Array a = Array(x);
       vec.reserve(a.size());
       for (std::size_t i = 0; i < a.size(); ++i) {
-        vec.push_back(from_ruby<BoolVar>(a[i]));
+        if (((Object) a[i]).is_a(rb_cSatIntVar)) {
+          vec.push_back(from_ruby<IntVar>(a[i]).ToBoolVar());
+        } else {
+          vec.push_back(from_ruby<BoolVar>(a[i]));
+        }
       }
     }
     operator absl::Span<const BoolVar>() {
@@ -152,13 +158,25 @@ BoolVarSpan from_ruby<BoolVarSpan>(Object x)
 }
 
 void init_constraint(Rice::Module& m) {
-  Rice::define_class_under<IntVar>(m, "SatIntVar")
+  rb_cSatIntVar = Rice::define_class_under<IntVar>(m, "SatIntVar")
     .define_method("name", &IntVar::Name);
 
   Rice::define_class_under<IntervalVar>(m, "SatIntervalVar")
     .define_method("name", &IntervalVar::Name);
 
-  Rice::define_class_under<Constraint>(m, "SatConstraint");
+  Rice::define_class_under<Constraint>(m, "SatConstraint")
+    .define_method(
+      "only_enforce_if",
+      *[](Constraint& self, Object literal) {
+        if (literal.is_a(rb_cSatIntVar)) {
+          return self.OnlyEnforceIf(from_ruby<IntVar>(literal).ToBoolVar());
+        } else if (literal.is_a(rb_cArray)) {
+          // TODO support IntVarSpan
+          return self.OnlyEnforceIf(from_ruby<BoolVarSpan>(literal));
+        } else {
+          return self.OnlyEnforceIf(from_ruby<BoolVar>(literal));
+        }
+      });
 
   Rice::define_class_under<BoolVar>(m, "BoolVar")
     .define_method("name", &BoolVar::Name)
@@ -182,13 +200,13 @@ void init_constraint(Rice::Module& m) {
     .define_constructor(Rice::Constructor<CpModelBuilder>())
     .define_method(
       "new_int_var",
-      *[](CpModelBuilder& self, int64 start, int64 end, std::string name) {
+      *[](CpModelBuilder& self, int64 start, int64 end, const std::string& name) {
         const operations_research::Domain domain(start, end);
         return self.NewIntVar(domain).WithName(name);
       })
     .define_method(
       "new_bool_var",
-      *[](CpModelBuilder& self, std::string name) {
+      *[](CpModelBuilder& self, const std::string& name) {
         return self.NewBoolVar().WithName(name);
       })
     .define_method(
@@ -208,124 +226,124 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "new_interval_var",
-      *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, std::string name) {
+      *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, const std::string& name) {
         return self.NewIntervalVar(start, size, end).WithName(name);
       })
     .define_method(
       "new_optional_interval_var",
-      *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, BoolVar presence, std::string name) {
+      *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, BoolVar presence, const std::string& name) {
         return self.NewOptionalIntervalVar(start, size, end, presence).WithName(name);
       })
     .define_method(
       "add_bool_or",
       *[](CpModelBuilder& self, BoolVarSpan literals) {
-        self.AddBoolOr(literals);
+        return self.AddBoolOr(literals);
       })
     .define_method(
       "add_bool_and",
       *[](CpModelBuilder& self, BoolVarSpan literals) {
-        self.AddBoolAnd(literals);
+        return self.AddBoolAnd(literals);
       })
     .define_method(
       "add_bool_xor",
       *[](CpModelBuilder& self, BoolVarSpan literals) {
-        self.AddBoolXor(literals);
+        return self.AddBoolXor(literals);
       })
     .define_method(
       "add_implication",
       *[](CpModelBuilder& self, BoolVar a, BoolVar b) {
-        self.AddImplication(a, b);
+        return self.AddImplication(a, b);
       })
     .define_method(
       "add_equality",
       *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddEquality(x, y);
+        return self.AddEquality(x, y);
       })
     .define_method(
       "add_greater_or_equal",
       *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddGreaterOrEqual(x, y);
+        return self.AddGreaterOrEqual(x, y);
       })
     .define_method(
       "add_greater_than",
       *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddGreaterThan(x, y);
+        return self.AddGreaterThan(x, y);
       })
     .define_method(
       "add_less_or_equal",
       *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddLessOrEqual(x, y);
+        return self.AddLessOrEqual(x, y);
       })
     .define_method(
       "add_less_than",
       *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddLessThan(x, y);
+        return self.AddLessThan(x, y);
       })
     // TODO add domain
     // .define_method(
     //   "add_linear_constraint",
     //   *[](CpModelBuilder& self, LinearExpr expr, Domain domain) {
-    //     self.AddLinearConstraint(expr, domain);
+    //     return self.AddLinearConstraint(expr, domain);
     //   })
     .define_method(
       "add_not_equal",
       *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
-        self.AddNotEqual(x, y);
+        return self.AddNotEqual(x, y);
       })
     .define_method(
       "add_all_different",
       *[](CpModelBuilder& self, IntVarSpan vars) {
-        self.AddAllDifferent(vars);
+        return self.AddAllDifferent(vars);
       })
     .define_method(
       "add_inverse_constraint",
       *[](CpModelBuilder& self, IntVarSpan variables, IntVarSpan inverse_variables) {
-        self.AddInverseConstraint(variables, inverse_variables);
+        return self.AddInverseConstraint(variables, inverse_variables);
       })
     .define_method(
       "add_min_equality",
       *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
-        self.AddMinEquality(target, vars);
+        return self.AddMinEquality(target, vars);
       })
     .define_method(
       "add_lin_min_equality",
       *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
-        self.AddLinMinEquality(target, exprs);
+        return self.AddLinMinEquality(target, exprs);
       })
     .define_method(
       "add_max_equality",
       *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
-        self.AddMaxEquality(target, vars);
+        return self.AddMaxEquality(target, vars);
       })
     .define_method(
       "add_lin_max_equality",
       *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
-        self.AddLinMaxEquality(target, exprs);
+        return self.AddLinMaxEquality(target, exprs);
       })
     .define_method(
       "add_division_equality",
       *[](CpModelBuilder& self, IntVar target, IntVar numerator, IntVar denominator) {
-        self.AddDivisionEquality(target, numerator, denominator);
+        return self.AddDivisionEquality(target, numerator, denominator);
       })
     .define_method(
       "add_abs_equality",
       *[](CpModelBuilder& self, IntVar target, IntVar var) {
-        self.AddAbsEquality(target, var);
+        return self.AddAbsEquality(target, var);
       })
     .define_method(
       "add_modulo_equality",
       *[](CpModelBuilder& self, IntVar target, IntVar var, IntVar mod) {
-        self.AddModuloEquality(target, var, mod);
+        return self.AddModuloEquality(target, var, mod);
       })
     .define_method(
       "add_product_equality",
       *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
-        self.AddProductEquality(target, vars);
+        return self.AddProductEquality(target, vars);
       })
     .define_method(
       "add_no_overlap",
       *[](CpModelBuilder& self, IntervalVarSpan vars) {
-        self.AddNoOverlap(vars);
+        return self.AddNoOverlap(vars);
       })
     .define_method(
       "maximize",
@@ -342,6 +360,31 @@ void init_constraint(Rice::Module& m) {
       *[](CpModelBuilder& self, double scaling) {
         self.ScaleObjectiveBy(scaling);
       })
+    .define_method(
+      "add_hint",
+      *[](CpModelBuilder& self, IntVar var, int64 value) {
+        self.AddHint(var, value);
+      })
+    .define_method(
+      "clear_hints",
+      *[](CpModelBuilder& self) {
+        self.ClearHints();
+      })
+    .define_method(
+      "add_assumption",
+      *[](CpModelBuilder& self, BoolVar lit) {
+        self.AddAssumption(lit);
+      })
+    .define_method(
+      "add_assumptions",
+      *[](CpModelBuilder& self, BoolVarSpan literals) {
+        self.AddAssumptions(literals);
+      })
+    .define_method(
+      "clear_assumptions",
+      *[](CpModelBuilder& self) {
+        self.ClearAssumptions();
+      })
     .define_method(
       "to_s",
       *[](CpModelBuilder& self) {

data/ext/or-tools/vendor.rb

@@ -18,16 +18,25 @@ else
     filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
     checksum = "0d052deb2ba4491c29e86242fb5d61d0fe14bac847c2feaa35fbeff925ea40a0"
   elsif os == "Debian" && os_version == "10"
-    filename = "or-tools_debian-10_v#{version}.tar.gz "
+    filename = "or-tools_debian-10_v#{version}.tar.gz"
     checksum = "1f2ec99181c92859ab46e68a6231babce92ded949fd1d08ee31afa4db04c43b3"
   elsif os == "CentOS" && os_version == "8"
     filename = "or-tools_centos-8_v#{version}.tar.gz"
     checksum = "be638a20b36f6da81aa29fd24c69c4a66afc980b8a221b1cbabb3910b9827718"
   else
+    platform =
+      if Gem.win_platform?
+        "Windows"
+      elsif os || os_version
+        "#{os} #{os_version}"
+      else
+        "Unknown"
+      end
+
     # there is a binary download for Windows
     # however, it's compiled with Visual Studio rather than MinGW (which RubyInstaller uses)
     raise <<~MSG
-      Binary installation not available for this platform.
+      Binary installation not available for this platform: #{platform}
 
       Build the OR-Tools C++ library from source, then run:
       bundle config build.or-tools --with-or-tools-dir=/path/to/or-tools
@@ -41,7 +50,9 @@ url = "https://github.com/google/or-tools/releases/download/v#{short_version}/#{
 
 $stdout.sync = true
 
-def download_file(url, download_path)
+def download_file(url, download_path, redirects = 0)
+  raise "Too many redirects" if redirects > 10
+
   uri = URI(url)
   location = nil
 
@@ -70,7 +81,7 @@ def download_file(url, download_path)
   end
 
   # outside of Net::HTTP block to close previous connection
-  download_file(location, download_path) if location
+  download_file(location, download_path, redirects + 1) if location
 end
 
 # download

data/lib/or_tools/version.rb

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

metadata

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