or-tools 0.1.3 → 0.1.4

data/ext/or-tools/ext.cpp

@@ -117,7 +117,7 @@ operations_research::sat::LinearExpr from_ruby<operations_research::sat::LinearE
       Object o = cvar[0];
       std::string type = ((String) o.call("class").call("name")).str();
       if (type == "ORTools::BoolVar") {
-        expr.AddVar(from_ruby<operations_research::sat::BoolVar>(cvar[0]));
+        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 {
@@ -125,7 +125,12 @@ operations_research::sat::LinearExpr from_ruby<operations_research::sat::LinearE
       }
     }
   } 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;
@@ -239,6 +244,50 @@ 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()
 {
@@ -338,10 +387,15 @@ 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(
       "*",
@@ -368,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) {
@@ -422,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) {
@@ -461,13 +531,18 @@ void Init_ext()
         }
       });
 
-  // not to be confused with operations_research::IntVar
   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) {
@@ -488,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) {
@@ -523,6 +603,22 @@ void Init_ext()
       *[](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) {
@@ -537,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) {

data/lib/or-tools.rb

@@ -4,6 +4,7 @@ require "or_tools/ext"
 # modules
 require "or_tools/comparison"
 require "or_tools/comparison_operators"
+require "or_tools/bool_var"
 require "or_tools/cp_model"
 require "or_tools/cp_solver"
 require "or_tools/cp_solver_solution_callback"

data/lib/or_tools/bool_var.rb

@@ -0,0 +1,9 @@
+module ORTools
+  class BoolVar
+    include ComparisonOperators
+
+    def *(other)
+      SatLinearExpr.new([[self, other]])
+    end
+  end
+end

data/lib/or_tools/cp_solver.rb

@@ -15,8 +15,13 @@ module ORTools
       _solution_integer_value(@response, var)
     end
 
+    def solve_with_solution_callback(model, observer)
+      @response = _solve_with_observer(model, observer, false)
+      @response.status
+    end
+
     def search_for_all_solutions(model, observer)
-      @response = _solve_with_observer(model, observer)
+      @response = _solve_with_observer(model, observer, true)
       @response.status
     end
   end

data/lib/or_tools/cp_solver_solution_callback.rb

@@ -12,5 +12,9 @@ module ORTools
         raise "Unsupported type"
       end
     end
+
+    def objective_value
+      @response.objective_value
+    end
   end
 end

data/lib/or_tools/linear_expr.rb

@@ -8,6 +8,14 @@ module ORTools
       end
     end
 
+    def >=(other)
+      if other.is_a?(LinearExpr)
+        _gte_linear_expr(other)
+      else
+        _gte_double(other)
+      end
+    end
+
     def <=(other)
       if other.is_a?(LinearExpr)
         _lte_linear_expr(other)

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-24 00:00:00.000000000 Z
+date: 2020-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -94,6 +94,7 @@ files:
 - ext/or-tools/ext.cpp
 - ext/or-tools/extconf.rb
 - lib/or-tools.rb
+- lib/or_tools/bool_var.rb
 - lib/or_tools/comparison.rb
 - lib/or_tools/comparison_operators.rb
 - lib/or_tools/cp_model.rb