or-tools 0.3.1 → 0.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 116cfa149eef398630f24b3776c9db8e0a1dddb2b17c8e4b04f347f064231c72
-  data.tar.gz: 9930c7e37bc26fd88a6c59eac718eb057d82990bc3ccb3bee3f395456baa9318
+  metadata.gz: 7ce5b035a9a0f52391ef97cd12d32ec7632101940fde4e2f19de4887900a4dc1
+  data.tar.gz: c63b37906fb5337cd805c627266422ccfc698d3759456327e2414f5e31e4ab52
 SHA512:
-  metadata.gz: eab3682edbfa9d3a90eb54ffe1697abd9f9e4dcb75ae6e08b08dfea1dcaedce4d773d3d53490d4c9de258d4d0e3b92e38bcb1cb4c5f4f50225e829c566b2c74b
-  data.tar.gz: '0514577229f62526c914a52b7164a2dc49b17515cbe798cd177f3a9dadc1da4a9026c45cec77830b08ac2bce44831f072ee18c6e3bdb9db66d958b6ed407d7b2'
+  metadata.gz: 5eda4c29a50790d7c569e67b9538ac2c13a6cd20af1580cd679a68d386244b5cd1bbafa311c52fe9cad519652bbfb6666aed09e6a5ae1f7c71cc666491644d4f
+  data.tar.gz: 5241d2788f6883ca0349967e4f953382cd03564fe4856e853888518427a2ed5ec8a8cf948aac34a02b39f413c787eeb98ff22284f59359f7cf9a9aa73b449188

data/CHANGELOG.md

@@ -1,3 +1,27 @@
+## 0.4.1 (2021-02-23)
+
+- Added solution printers
+- Improved `inspect` and `to_s` for `CpModel`
+- Improved constraint construction
+
+## 0.4.0 (2021-01-14)
+
+- Updated OR-Tools to 8.1
+
+## 0.3.4 (2021-01-14)
+
+- Added support for time limit for `CpSolver`
+- Added `add_dimension_with_vehicle_transits` and `status` methods to `RoutingModel`
+
+## 0.3.3 (2020-10-12)
+
+- Added support for start and end points for routing
+
+## 0.3.2 (2020-08-04)
+
+- Updated OR-Tools to 7.8
+- Added binary installation for Ubuntu 20.04
+
 ## 0.3.1 (2020-07-21)
 
 - Reduced gem size

data/NOTICE.txt

@@ -1,4 +1,5 @@
-Copyright 2020 Andrew Kane
+Copyright 2010-2018 Google LLC
+Copyright 2020-2021 Andrew Kane
 
 Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.

data/README.md

@@ -2,7 +2,7 @@
 
 [OR-Tools](https://github.com/google/or-tools) - operations research tools - for Ruby
 
-[![Build Status](https://travis-ci.org/ankane/or-tools.svg?branch=master)](https://travis-ci.org/ankane/or-tools)
+[![Build Status](https://github.com/ankane/or-tools/workflows/build/badge.svg?branch=master)](https://github.com/ankane/or-tools/actions)
 
 ## Installation
 
@@ -267,6 +267,7 @@ Constraint Optimization
 - [Solving an Optimization Problem](#solving-an-optimization-problem)
 - [Cryptarithmetic](#cryptarithmetic)
 - [The N-queens Problem](#the-n-queens-problem)
+- [Setting Solver Limits](#setting-solver-limits)
 
 Assignment
 
@@ -578,6 +579,39 @@ puts
 puts "Solutions found : %i" % solution_printer.solution_count
 ```
 
+### Setting Solver Limits
+
+[Guide](https://developers.google.com/optimization/cp/cp_tasks)
+
+```ruby
+# create the model
+model = ORTools::CpModel.new
+
+# create the variables
+num_vals = 3
+x = model.new_int_var(0, num_vals - 1, "x")
+y = model.new_int_var(0, num_vals - 1, "y")
+z = model.new_int_var(0, num_vals - 1, "z")
+
+# add an all-different constraint
+model.add(x != y)
+
+# create the solver
+solver = ORTools::CpSolver.new
+
+# set a time limit of 10 seconds.
+solver.parameters.max_time_in_seconds = 10
+
+# solve the model
+status = solver.solve(model)
+
+# display the first solution
+if status == :optimal
+  puts "x = #{solver.value(x)}"
+  puts "y = #{solver.value(y)}"
+  puts "z = #{solver.value(z)}"
+end
+```
 
 ### Assignment
 

data/ext/or-tools/assignment.cpp

@@ -0,0 +1,39 @@
+#include <ortools/graph/assignment.h>
+
+#include <rice/Array.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Module.hpp>
+
+using operations_research::SimpleLinearSumAssignment;
+
+using Rice::Array;
+using Rice::Symbol;
+
+void init_assignment(Rice::Module& m) {
+  Rice::define_class_under<SimpleLinearSumAssignment>(m, "LinearSumAssignment")
+    .define_constructor(Rice::Constructor<SimpleLinearSumAssignment>())
+    .define_method("add_arc_with_cost", &SimpleLinearSumAssignment::AddArcWithCost)
+    .define_method("num_nodes", &SimpleLinearSumAssignment::NumNodes)
+    .define_method("num_arcs", &SimpleLinearSumAssignment::NumArcs)
+    .define_method("left_node", &SimpleLinearSumAssignment::LeftNode)
+    .define_method("right_node", &SimpleLinearSumAssignment::RightNode)
+    .define_method("cost", &SimpleLinearSumAssignment::Cost)
+    .define_method("optimal_cost", &SimpleLinearSumAssignment::OptimalCost)
+    .define_method("right_mate", &SimpleLinearSumAssignment::RightMate)
+    .define_method("assignment_cost", &SimpleLinearSumAssignment::AssignmentCost)
+    .define_method(
+      "solve",
+      *[](SimpleLinearSumAssignment& self) {
+        auto status = self.Solve();
+
+        if (status == SimpleLinearSumAssignment::Status::OPTIMAL) {
+          return Symbol("optimal");
+        } else if (status == SimpleLinearSumAssignment::Status::INFEASIBLE) {
+          return Symbol("infeasible");
+        } else if (status == SimpleLinearSumAssignment::Status::POSSIBLE_OVERFLOW) {
+          return Symbol("possible_overflow");
+        } else {
+          throw std::runtime_error("Unknown status");
+        }
+      });
+}

data/ext/or-tools/bin_packing.cpp

@@ -0,0 +1,55 @@
+#include <ortools/algorithms/knapsack_solver.h>
+
+#include <rice/Array.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Module.hpp>
+
+using operations_research::KnapsackSolver;
+
+using Rice::Array;
+using Rice::Object;
+using Rice::Symbol;
+
+template<>
+inline
+KnapsackSolver::SolverType from_ruby<KnapsackSolver::SolverType>(Object x)
+{
+  std::string s = Symbol(x).str();
+  if (s == "branch_and_bound") {
+    return KnapsackSolver::KNAPSACK_MULTIDIMENSION_BRANCH_AND_BOUND_SOLVER;
+  } else {
+    throw std::runtime_error("Unknown solver type: " + s);
+  }
+}
+
+void init_bin_packing(Rice::Module& m) {
+  Rice::define_class_under<KnapsackSolver>(m, "KnapsackSolver")
+    .define_constructor(Rice::Constructor<KnapsackSolver, KnapsackSolver::SolverType, std::string>())
+    .define_method("_solve", &KnapsackSolver::Solve)
+    .define_method("best_solution_contains?", &KnapsackSolver::BestSolutionContains)
+    .define_method(
+      "init",
+      *[](KnapsackSolver& self, Array rb_values, Array rb_weights, Array rb_capacities) {
+        std::vector<int64> values;
+        for (std::size_t i = 0; i < rb_values.size(); ++i) {
+          values.push_back(from_ruby<int64>(rb_values[i]));
+        }
+
+        std::vector<std::vector<int64>> weights;
+        for (std::size_t i = 0; i < rb_weights.size(); ++i) {
+          Array rb_w = Array(rb_weights[i]);
+          std::vector<int64> w;
+          for (std::size_t j = 0; j < rb_w.size(); ++j) {
+            w.push_back(from_ruby<int64>(rb_w[j]));
+          }
+          weights.push_back(w);
+        }
+
+        std::vector<int64> capacities;
+        for (std::size_t i = 0; i < rb_capacities.size(); ++i) {
+          capacities.push_back(from_ruby<int64>(rb_capacities[i]));
+        }
+
+        self.Init(values, weights, capacities);
+      });
+}

data/ext/or-tools/constraint.cpp

@@ -0,0 +1,423 @@
+#include <google/protobuf/text_format.h>
+#include <ortools/sat/cp_model.h>
+
+#include <rice/Array.hpp>
+#include <rice/Constructor.hpp>
+#include <rice/Module.hpp>
+
+using operations_research::sat::BoolVar;
+using operations_research::sat::Constraint;
+using operations_research::sat::CpModelBuilder;
+using operations_research::sat::CpSolverResponse;
+using operations_research::sat::CpSolverStatus;
+using operations_research::sat::LinearExpr;
+using operations_research::sat::IntVar;
+using operations_research::sat::IntervalVar;
+using operations_research::sat::Model;
+using operations_research::sat::NewFeasibleSolutionObserver;
+using operations_research::sat::SatParameters;
+using operations_research::sat::SolutionBooleanValue;
+using operations_research::sat::SolutionIntegerValue;
+
+using Rice::Array;
+using Rice::Object;
+using Rice::String;
+using Rice::Symbol;
+
+template<>
+inline
+LinearExpr from_ruby<LinearExpr>(Object x)
+{
+  LinearExpr expr;
+
+  if (x.respond_to("to_i")) {
+    expr = from_ruby<int64>(x.call("to_i"));
+  } else if (x.respond_to("vars")) {
+    Array vars = x.call("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]));
+      } else {
+        expr.AddTerm(from_ruby<IntVar>(cvar[0]), from_ruby<int64>(cvar[1]));
+      }
+    }
+  } 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);
+    }
+  }
+
+  return expr;
+}
+
+// need a wrapper class since absl::Span doesn't own
+class IntVarSpan {
+  std::vector<IntVar> vec;
+  public:
+    IntVarSpan(Object x) {
+      Array a = Array(x);
+      vec.reserve(a.size());
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<IntVar>(a[i]));
+      }
+    }
+    operator absl::Span<const IntVar>() {
+      return absl::Span<const 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<IntervalVar> vec;
+  public:
+    IntervalVarSpan(Object x) {
+      Array a = Array(x);
+      vec.reserve(a.size());
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<IntervalVar>(a[i]));
+      }
+    }
+    operator absl::Span<const IntervalVar>() {
+      return absl::Span<const IntervalVar>(vec);
+    }
+};
+
+template<>
+inline
+IntervalVarSpan from_ruby<IntervalVarSpan>(Object x)
+{
+  return IntervalVarSpan(x);
+}
+
+// need a wrapper class since absl::Span doesn't own
+class LinearExprSpan {
+  std::vector<LinearExpr> vec;
+  public:
+    LinearExprSpan(Object x) {
+      Array a = Array(x);
+      vec.reserve(a.size());
+      for (std::size_t i = 0; i < a.size(); ++i) {
+        vec.push_back(from_ruby<LinearExpr>(a[i]));
+      }
+    }
+    operator absl::Span<const LinearExpr>() {
+      return absl::Span<const LinearExpr>(vec);
+    }
+};
+
+template<>
+inline
+LinearExprSpan from_ruby<LinearExprSpan>(Object x)
+{
+  return LinearExprSpan(x);
+}
+
+// need a wrapper class since absl::Span doesn't own
+class BoolVarSpan {
+  std::vector<BoolVar> vec;
+  public:
+    BoolVarSpan(Object x) {
+      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]));
+      }
+    }
+    operator absl::Span<const BoolVar>() {
+      return absl::Span<const BoolVar>(vec);
+    }
+};
+
+template<>
+inline
+BoolVarSpan from_ruby<BoolVarSpan>(Object x)
+{
+  return BoolVarSpan(x);
+}
+
+void init_constraint(Rice::Module& m) {
+  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<BoolVar>(m, "BoolVar")
+    .define_method("name", &BoolVar::Name)
+    .define_method("index", &BoolVar::index)
+    .define_method("not", &BoolVar::Not)
+    .define_method(
+      "inspect",
+      *[](BoolVar& self) {
+        String name(self.Name());
+        return "#<ORTools::BoolVar @name=" + name.inspect().str() + ">";
+      });
+
+  Rice::define_class_under<SatParameters>(m, "SatParameters")
+    .define_constructor(Rice::Constructor<SatParameters>())
+    .define_method("max_time_in_seconds=",
+    *[](SatParameters& self, double value) {
+      self.set_max_time_in_seconds(value);
+    });
+
+  Rice::define_class_under<CpModelBuilder>(m, "CpModel")
+    .define_constructor(Rice::Constructor<CpModelBuilder>())
+    .define_method(
+      "new_int_var",
+      *[](CpModelBuilder& self, int64 start, int64 end, 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) {
+        return self.NewBoolVar().WithName(name);
+      })
+    .define_method(
+      "new_constant",
+      *[](CpModelBuilder& self, int64 value) {
+        return self.NewConstant(value);
+      })
+    .define_method(
+      "true_var",
+      *[](CpModelBuilder& self) {
+        return self.TrueVar();
+      })
+    .define_method(
+      "false_var",
+      *[](CpModelBuilder& self) {
+        return self.FalseVar();
+      })
+    .define_method(
+      "new_interval_var",
+      *[](CpModelBuilder& self, IntVar start, IntVar size, IntVar end, 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) {
+        return self.NewOptionalIntervalVar(start, size, end, presence).WithName(name);
+      })
+    .define_method(
+      "add_bool_or",
+      *[](CpModelBuilder& self, BoolVarSpan literals) {
+        self.AddBoolOr(literals);
+      })
+    .define_method(
+      "add_bool_and",
+      *[](CpModelBuilder& self, BoolVarSpan literals) {
+        self.AddBoolAnd(literals);
+      })
+    .define_method(
+      "add_bool_xor",
+      *[](CpModelBuilder& self, BoolVarSpan literals) {
+        self.AddBoolXor(literals);
+      })
+    .define_method(
+      "add_implication",
+      *[](CpModelBuilder& self, BoolVar a, BoolVar b) {
+        self.AddImplication(a, b);
+      })
+    .define_method(
+      "add_equality",
+      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        self.AddEquality(x, y);
+      })
+    .define_method(
+      "add_greater_or_equal",
+      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        self.AddGreaterOrEqual(x, y);
+      })
+    .define_method(
+      "add_greater_than",
+      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        self.AddGreaterThan(x, y);
+      })
+    .define_method(
+      "add_less_or_equal",
+      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        self.AddLessOrEqual(x, y);
+      })
+    .define_method(
+      "add_less_than",
+      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        self.AddLessThan(x, y);
+      })
+    // TODO add domain
+    // .define_method(
+    //   "add_linear_constraint",
+    //   *[](CpModelBuilder& self, LinearExpr expr, Domain domain) {
+    //     self.AddLinearConstraint(expr, domain);
+    //   })
+    .define_method(
+      "add_not_equal",
+      *[](CpModelBuilder& self, LinearExpr x, LinearExpr y) {
+        self.AddNotEqual(x, y);
+      })
+    .define_method(
+      "add_all_different",
+      *[](CpModelBuilder& self, IntVarSpan vars) {
+        self.AddAllDifferent(vars);
+      })
+    .define_method(
+      "add_inverse_constraint",
+      *[](CpModelBuilder& self, IntVarSpan variables, IntVarSpan inverse_variables) {
+        self.AddInverseConstraint(variables, inverse_variables);
+      })
+    .define_method(
+      "add_min_equality",
+      *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
+        self.AddMinEquality(target, vars);
+      })
+    .define_method(
+      "add_lin_min_equality",
+      *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
+        self.AddLinMinEquality(target, exprs);
+      })
+    .define_method(
+      "add_max_equality",
+      *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
+        self.AddMaxEquality(target, vars);
+      })
+    .define_method(
+      "add_lin_max_equality",
+      *[](CpModelBuilder& self, LinearExpr target, LinearExprSpan exprs) {
+        self.AddLinMaxEquality(target, exprs);
+      })
+    .define_method(
+      "add_division_equality",
+      *[](CpModelBuilder& self, IntVar target, IntVar numerator, IntVar denominator) {
+        self.AddDivisionEquality(target, numerator, denominator);
+      })
+    .define_method(
+      "add_abs_equality",
+      *[](CpModelBuilder& self, IntVar target, IntVar var) {
+        self.AddAbsEquality(target, var);
+      })
+    .define_method(
+      "add_modulo_equality",
+      *[](CpModelBuilder& self, IntVar target, IntVar var, IntVar mod) {
+        self.AddModuloEquality(target, var, mod);
+      })
+    .define_method(
+      "add_product_equality",
+      *[](CpModelBuilder& self, IntVar target, IntVarSpan vars) {
+        self.AddProductEquality(target, vars);
+      })
+    .define_method(
+      "add_no_overlap",
+      *[](CpModelBuilder& self, IntervalVarSpan vars) {
+        self.AddNoOverlap(vars);
+      })
+    .define_method(
+      "maximize",
+      *[](CpModelBuilder& self, LinearExpr expr) {
+        self.Maximize(expr);
+      })
+    .define_method(
+      "minimize",
+      *[](CpModelBuilder& self, LinearExpr expr) {
+        self.Minimize(expr);
+      })
+    .define_method(
+      "scale_objective_by",
+      *[](CpModelBuilder& self, double scaling) {
+        self.ScaleObjectiveBy(scaling);
+      })
+    .define_method(
+      "to_s",
+      *[](CpModelBuilder& self) {
+        std::string proto_string;
+        google::protobuf::TextFormat::PrintToString(self.Proto(), &proto_string);
+        return proto_string;
+      });
+
+  Rice::define_class_under(m, "CpSolver")
+    .define_method(
+      "_solve_with_observer",
+      *[](Object self, CpModelBuilder& model, SatParameters& parameters, Object callback, bool all_solutions) {
+        Model m;
+
+        if (all_solutions) {
+          // set parameters for SearchForAllSolutions
+          parameters.set_enumerate_all_solutions(true);
+        }
+        m.Add(NewSatParameters(parameters));
+
+        m.Add(NewFeasibleSolutionObserver(
+          [callback](const CpSolverResponse& r) {
+            // TODO find a better way to do this
+            callback.call("response=", r);
+            callback.call("on_solution_callback");
+          })
+        );
+        return SolveCpModel(model.Build(), &m);
+      })
+    .define_method(
+      "_solve",
+      *[](Object self, CpModelBuilder& model, SatParameters& parameters) {
+        Model m;
+        m.Add(NewSatParameters(parameters));
+        return SolveCpModel(model.Build(), &m);
+      })
+    .define_method(
+      "_solution_integer_value",
+      *[](Object self, CpSolverResponse& response, IntVar& x) {
+        return SolutionIntegerValue(response, x);
+      })
+    .define_method(
+      "_solution_boolean_value",
+      *[](Object self, CpSolverResponse& response, BoolVar& x) {
+        return SolutionBooleanValue(response, x);
+      });
+
+  Rice::define_class_under<CpSolverResponse>(m, "CpSolverResponse")
+    .define_method("objective_value", &CpSolverResponse::objective_value)
+    .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",
+      *[](CpSolverResponse& self, IntVar& x) {
+        LinearExpr expr(x);
+        return SolutionIntegerValue(self, expr);
+      })
+    .define_method("solution_boolean_value", &SolutionBooleanValue)
+    .define_method(
+      "status",
+      *[](CpSolverResponse& self) {
+        auto status = self.status();
+
+        if (status == CpSolverStatus::OPTIMAL) {
+          return Symbol("optimal");
+        } else if (status == CpSolverStatus::FEASIBLE) {
+          return Symbol("feasible");
+        } else if (status == CpSolverStatus::INFEASIBLE) {
+          return Symbol("infeasible");
+        } else if (status == CpSolverStatus::MODEL_INVALID) {
+          return Symbol("model_invalid");
+        } else if (status == CpSolverStatus::UNKNOWN) {
+          return Symbol("unknown");
+        } else {
+          throw std::runtime_error("Unknown solver status");
+        }
+      });
+}