or-tools 0.13.1 → 0.14.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4863311462c6b8ec192b18548667397398e2b7f183c01922fdfe3d464157a9fc
-  data.tar.gz: 2e0ad658ab77b7c18aa449fad095d0dfa6c098b8bae80fd7d1ea1dbcae4b292f
+  metadata.gz: 5803be6e2ff6de980c6f1a89ab9ccda1e2ee264139229bca865103c8379dc4a2
+  data.tar.gz: 323fda85d36cc8dadb6720a23ac3e9eaa881e3618e74044c8b04773bb979c16e
 SHA512:
-  metadata.gz: 6135045892abd2f572bd40603d36024e3984f7dfec10b1c40cc49dbc21c381d4b81c3e2cbe795f51fe52ecc88b579fa15b99cb8455872459649865be14031d4b
-  data.tar.gz: e0df2a74200821b3d55f78cdf764d2720724449931298a2bb902c395587cd0b7117094b629e226273c65f5492b4846f2d7a26f753eb1d126088905a8ecad6354
+  metadata.gz: 48c9eba03b16bb2ce63edf62d52f33fc88595e691543f68dd1a2090adb7212958331534a97b801c7f54acce6626461bc0e268ac312ea34c1c50045dedcfbb3b4
+  data.tar.gz: 8d91150d41201f8e47129ef3b48cfb4b63b5cb91c09c87d7ef01f87de4b82ff6d287fb2ca5e3b5a4984152bdb2e5a33f4c5b8fe9495d6a9e89ab81b31c1674ac

data/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 0.14.1 (2024-12-04)
+
+- Added support for parameters to `Solver`
+- Fixed error with `inspect` for `MathOpt` variables
+
+## 0.14.0 (2024-10-22)
+
+- Added experimental support for `MathOpt`
+- Unified model building across solvers
+
 ## 0.13.1 (2024-10-05)
 
 - Added binary installation for Debian 12

data/README.md

@@ -23,6 +23,10 @@ Higher Level Interfaces
 - [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp)
 - [Sudoku](#sudoku)
 
+MathOpt
+
+- [Basic example](#basic-example)
+
 Linear Optimization
 
 - [Solving an LP Problem](#solving-an-lp-problem)
@@ -89,15 +93,15 @@ Specify people and their availabililty
 people = [
   {
     availability: [
-      {starts_at: Time.parse("2020-01-01 08:00:00"), ends_at: Time.parse("2020-01-01 16:00:00")},
-      {starts_at: Time.parse("2020-01-02 08:00:00"), ends_at: Time.parse("2020-01-02 16:00:00")}
+      {starts_at: Time.parse("2025-01-01 08:00:00"), ends_at: Time.parse("2025-01-01 16:00:00")},
+      {starts_at: Time.parse("2025-01-02 08:00:00"), ends_at: Time.parse("2025-01-02 16:00:00")}
     ],
     max_hours: 40 # optional, applies to entire scheduling period
   },
   {
     availability: [
-      {starts_at: Time.parse("2020-01-01 08:00:00"), ends_at: Time.parse("2020-01-01 16:00:00")},
-      {starts_at: Time.parse("2020-01-03 08:00:00"), ends_at: Time.parse("2020-01-03 16:00:00")}
+      {starts_at: Time.parse("2025-01-01 08:00:00"), ends_at: Time.parse("2025-01-01 16:00:00")},
+      {starts_at: Time.parse("2025-01-03 08:00:00"), ends_at: Time.parse("2025-01-03 16:00:00")}
     ],
     max_hours: 20
   }
@@ -108,9 +112,9 @@ Specify shifts
 
 ```ruby
 shifts = [
-  {starts_at: Time.parse("2020-01-01 08:00:00"), ends_at: Time.parse("2020-01-01 16:00:00")},
-  {starts_at: Time.parse("2020-01-02 08:00:00"), ends_at: Time.parse("2020-01-02 16:00:00")},
-  {starts_at: Time.parse("2020-01-03 08:00:00"), ends_at: Time.parse("2020-01-03 16:00:00")}
+  {starts_at: Time.parse("2025-01-01 08:00:00"), ends_at: Time.parse("2025-01-01 16:00:00")},
+  {starts_at: Time.parse("2025-01-02 08:00:00"), ends_at: Time.parse("2025-01-02 16:00:00")},
+  {starts_at: Time.parse("2025-01-03 08:00:00"), ends_at: Time.parse("2025-01-03 16:00:00")}
 ]
 ```
 
@@ -311,6 +315,29 @@ sudoku = ORTools::Sudoku.new(grid, x: true, anti_knight: true, magic_square: tru
 sudoku.solution
 ```
 
+## MathOpt
+
+### Basic Example
+
+[Guide](https://developers.google.com/optimization/math_opt/basic_example)
+
+```ruby
+# build the model
+model = ORTools::MathOpt::Model.new("getting_started_lp")
+x = model.add_variable(-1.0, 1.5, "x")
+y = model.add_variable(0.0, 1.0, "y")
+model.add_linear_constraint(x + y <= 1.5)
+model.maximize(x + 2 * y)
+
+# solve
+result = model.solve
+
+# inspect the solution
+puts "Objective value: #{result.objective_value}"
+puts "x: #{result.variable_values[x]}"
+puts "y: #{result.variable_values[y]}"
+```
+
 ## Linear Optimization
 
 ### Solving an LP Problem

data/ext/or-tools/constraint.cpp

@@ -44,63 +44,33 @@ namespace Rice::detail
   public:
     LinearExpr convert(VALUE v)
     {
-      Object x(v);
       LinearExpr expr;
 
-      if (x.respond_to("to_i")) {
-        expr = From_Ruby<int64_t>().convert(x.call("to_i").value());
-      } else if (x.respond_to("vars")) {
-        Array vars = x.call("vars");
-        for (const auto& v : vars) {
-          // TODO clean up
-          auto cvar = (Array) v;
-          Object var = cvar[0];
-          auto coeff = From_Ruby<int64_t>().convert(cvar[1].value());
+      Rice::Object utils = Rice::define_module("ORTools").const_get("Utils");
+      Rice::Hash coeffs = utils.call("index_expression", Object(v));
 
-          if (var.is_a(rb_cBoolVar)) {
-            expr += From_Ruby<BoolVar>().convert(var.value()) * coeff;
-          } else if (var.is_a(rb_cInteger)) {
-            expr += From_Ruby<int64_t>().convert(var.value()) * coeff;
-          } else {
-            expr += From_Ruby<IntVar>().convert(var.value()) * coeff;
-          }
-        }
-      } else {
-        if (x.is_a(rb_cBoolVar)) {
-          expr = From_Ruby<BoolVar>().convert(x.value());
+      for (const auto& entry : coeffs) {
+        Object var = entry.key;
+        auto coeff = From_Ruby<int64_t>().convert(entry.value.value());
+
+        if (var.is_nil()) {
+          expr += coeff;
+        } else if (var.is_a(rb_cBoolVar)) {
+          expr += From_Ruby<BoolVar>().convert(var.value()) * coeff;
         } else {
-          expr = From_Ruby<IntVar>().convert(x.value());
+          expr += From_Ruby<IntVar>().convert(var.value()) * coeff;
         }
       }
 
       return expr;
     }
   };
-
-  template<>
-  class From_Ruby<std::vector<BoolVar>>
-  {
-  public:
-    std::vector<BoolVar> convert(VALUE v)
-    {
-      auto a = Array(v);
-      std::vector<BoolVar> vec;
-      vec.reserve(a.size());
-      for (const Object v : a) {
-        if (v.is_a(rb_cSatIntVar)) {
-          vec.push_back(From_Ruby<IntVar>().convert(v.value()).ToBoolVar());
-        } else {
-          vec.push_back(From_Ruby<BoolVar>().convert(v.value()));
-        }
-      }
-      return vec;
-    }
-  };
 }
 
 void init_constraint(Rice::Module& m) {
   Rice::define_class_under<Domain>(m, "Domain")
     .define_constructor(Rice::Constructor<Domain, int64_t, int64_t>())
+    .define_singleton_function("from_values", &Domain::FromValues)
     .define_method("min", &Domain::Min)
     .define_method("max", &Domain::Max);
 
@@ -119,13 +89,23 @@ void init_constraint(Rice::Module& m) {
           return self.OnlyEnforceIf(Rice::detail::From_Ruby<IntVar>().convert(literal).ToBoolVar());
         } else if (literal.is_a(rb_cArray)) {
           // TODO support IntVarSpan
-          return self.OnlyEnforceIf(Rice::detail::From_Ruby<std::vector<BoolVar>>().convert(literal));
+          auto a = Array(literal);
+          std::vector<BoolVar> vec;
+          vec.reserve(a.size());
+          for (const Object v : a) {
+            if (v.is_a(rb_cSatIntVar)) {
+              vec.push_back(Rice::detail::From_Ruby<IntVar>().convert(v.value()).ToBoolVar());
+            } else {
+              vec.push_back(Rice::detail::From_Ruby<BoolVar>().convert(v.value()));
+            }
+          }
+          return self.OnlyEnforceIf(vec);
         } else {
           return self.OnlyEnforceIf(Rice::detail::From_Ruby<BoolVar>().convert(literal));
         }
       });
 
-  rb_cBoolVar = Rice::define_class_under<BoolVar>(m, "BoolVar")
+  rb_cBoolVar = Rice::define_class_under<BoolVar>(m, "SatBoolVar")
     .define_method("name", &BoolVar::Name)
     .define_method("index", &BoolVar::index)
     .define_method("not", &BoolVar::Not)
@@ -425,17 +405,17 @@ void init_constraint(Rice::Module& m) {
         Model m;
 
         if (!callback.is_nil()) {
-          // TODO figure out how to use callback with multiple cores
+          // use a single worker since Ruby code cannot be run in a non-Ruby thread
           parameters.set_num_search_workers(1);
 
           m.Add(NewFeasibleSolutionObserver(
             [&callback](const CpSolverResponse& r) {
-              // ensure Ruby thread
-              if (ruby_native_thread_p()) {
-                // TODO find a better way to do this
-                callback.call("response=", r);
-                callback.call("on_solution_callback");
+              if (!ruby_native_thread_p()) {
+                throw std::runtime_error("Non-Ruby thread");
               }
+
+              callback.call("response=", r);
+              callback.call("on_solution_callback");
             })
           );
         }

data/ext/or-tools/ext.cpp

@@ -10,6 +10,7 @@ void init_assignment(Rice::Module& m);
 void init_bin_packing(Rice::Module& m);
 void init_constraint(Rice::Module& m);
 void init_linear(Rice::Module& m);
+void init_math_opt(Rice::Module& m);
 void init_network_flows(Rice::Module& m);
 void init_routing(Rice::Module& m);
 
@@ -24,6 +25,7 @@ void Init_ext()
   init_bin_packing(m);
   init_constraint(m);
   init_linear(m);
+  init_math_opt(m);
   init_network_flows(m);
   init_routing(m);
 

data/ext/or-tools/extconf.rb

@@ -2,8 +2,14 @@ require "mkmf-rice"
 
 $CXXFLAGS << " -std=c++17 $(optflags) -DUSE_CBC"
 
-# or-tools warnings
-$CXXFLAGS << " -Wno-sign-compare -Wno-shorten-64-to-32 -Wno-ignored-qualifiers"
+# show warnings
+$CXXFLAGS << " -Wall -Wextra"
+
+# hide or-tools warnings
+$CXXFLAGS << " -Wno-sign-compare -Wno-ignored-qualifiers -Wno-unused-parameter -Wno-missing-field-initializers"
+
+# hide Rice warnings
+$CXXFLAGS << " -Wno-implicit-fallthrough"
 
 inc, lib = dir_config("or-tools")
 if inc || lib

data/ext/or-tools/linear.cpp

@@ -2,10 +2,9 @@
 
 #include "ext.h"
 
-using operations_research::LinearExpr;
-using operations_research::LinearRange;
 using operations_research::MPConstraint;
 using operations_research::MPObjective;
+using operations_research::MPSolverParameters;
 using operations_research::MPSolver;
 using operations_research::MPVariable;
 
@@ -45,12 +44,7 @@ namespace Rice::detail
 }
 
 void init_linear(Rice::Module& m) {
-  Rice::define_class_under<LinearRange>(m, "LinearRange");
-
-  auto rb_cLinearExpr = Rice::define_class_under<LinearExpr>(m, "LinearExpr");
-  rb_cLinearExpr.define_constructor(Rice::Constructor<LinearExpr>());
-
-  Rice::define_class_under<MPVariable, LinearExpr>(m, "MPVariable")
+  Rice::define_class_under<MPVariable>(m, "MPVariable")
     .define_method("name", &MPVariable::name)
     .define_method("solution_value", &MPVariable::solution_value);
 
@@ -63,10 +57,104 @@ void init_linear(Rice::Module& m) {
     .define_method("set_coefficient", &MPObjective::SetCoefficient)
     .define_method("set_offset", &MPObjective::SetOffset)
     .define_method("set_maximization", &MPObjective::SetMaximization)
+    .define_method("best_bound", &MPObjective::BestBound)
     .define_method("set_minimization", &MPObjective::SetMinimization);
 
+  Rice::define_class_under<MPSolverParameters>(m, "MPSolverParameters")
+    .define_constructor(Rice::Constructor<MPSolverParameters>())
+    .define_method("reset", &MPSolverParameters::Reset)
+    .define_method(
+      "relative_mip_gap=",
+      [](MPSolverParameters& self, double relative_mip_gap) {
+        self.SetDoubleParam(MPSolverParameters::DoubleParam::RELATIVE_MIP_GAP, relative_mip_gap);
+      })
+    .define_method(
+      "relative_mip_gap",
+      [](MPSolverParameters& self) {
+        return self.GetDoubleParam(MPSolverParameters::DoubleParam::RELATIVE_MIP_GAP);
+      })
+    .define_method(
+      "primal_tolerance=",
+      [](MPSolverParameters& self, double primal_tolerance) {
+        self.SetDoubleParam(MPSolverParameters::DoubleParam::PRIMAL_TOLERANCE, primal_tolerance);
+      })
+    .define_method(
+      "primal_tolerance",
+      [](MPSolverParameters& self) {
+        return self.GetDoubleParam(MPSolverParameters::DoubleParam::PRIMAL_TOLERANCE);
+      })
+    .define_method(
+      "dual_tolerance=",
+      [](MPSolverParameters& self, double dual_tolerance) {
+        self.SetDoubleParam(MPSolverParameters::DoubleParam::DUAL_TOLERANCE, dual_tolerance);
+      })
+    .define_method(
+      "dual_tolerance",
+      [](MPSolverParameters& self) {
+        return self.GetDoubleParam(MPSolverParameters::DoubleParam::DUAL_TOLERANCE);
+      })
+    .define_method(
+      "presolve=",
+      [](MPSolverParameters& self, bool value) {
+        int presolve;
+        if (value) {
+          presolve = MPSolverParameters::PresolveValues::PRESOLVE_ON;
+        } else {
+          presolve = MPSolverParameters::PresolveValues::PRESOLVE_OFF;
+        }
+        self.SetIntegerParam(MPSolverParameters::IntegerParam::PRESOLVE, presolve);
+      })
+    .define_method(
+      "presolve",
+      [](MPSolverParameters& self) {
+        int presolve = self.GetIntegerParam(MPSolverParameters::IntegerParam::PRESOLVE);
+        return presolve != MPSolverParameters::PresolveValues::PRESOLVE_OFF;
+      })
+    .define_method(
+      "incrementality=",
+      [](MPSolverParameters& self, bool value) {
+        int incrementality;
+        if (value) {
+          incrementality = MPSolverParameters::IncrementalityValues::INCREMENTALITY_ON;
+        } else {
+          incrementality = MPSolverParameters::IncrementalityValues::INCREMENTALITY_OFF;
+        }
+        self.SetIntegerParam(MPSolverParameters::IntegerParam::INCREMENTALITY, incrementality);
+      })
+    .define_method(
+      "incrementality",
+      [](MPSolverParameters& self) {
+        int incrementality = self.GetIntegerParam(MPSolverParameters::IntegerParam::INCREMENTALITY);
+        return incrementality != MPSolverParameters::IncrementalityValues::INCREMENTALITY_OFF;
+      })
+    .define_method(
+      "scaling=",
+      [](MPSolverParameters& self, bool value) {
+        int scaling;
+        if (value) {
+          scaling = MPSolverParameters::ScalingValues::SCALING_ON;
+        } else {
+          scaling = MPSolverParameters::ScalingValues::SCALING_OFF;
+        }
+        self.SetIntegerParam(MPSolverParameters::IntegerParam::SCALING, scaling);
+      })
+    .define_method(
+      "scaling",
+      [](MPSolverParameters& self) {
+        int scaling = self.GetIntegerParam(MPSolverParameters::IntegerParam::SCALING);
+        return scaling != MPSolverParameters::ScalingValues::SCALING_OFF;
+      });
+
   Rice::define_class_under<MPSolver>(m, "Solver")
-    .define_constructor(Rice::Constructor<MPSolver, std::string, MPSolver::OptimizationProblemType>())
+    .define_singleton_function(
+      "_new",
+      [](const std::string& name, MPSolver::OptimizationProblemType problem_type) {
+        std::unique_ptr<MPSolver> solver(new MPSolver(name, problem_type));
+        if (!solver) {
+          throw std::runtime_error("Unrecognized solver type");
+        }
+        return solver;
+      })
     .define_singleton_function(
       "_create",
       [](const std::string& solver_id) {
@@ -108,9 +196,9 @@ void init_linear(Rice::Module& m) {
         return self.MakeRowConstraint(lb, ub);
       })
     .define_method(
-      "solve",
-      [](MPSolver& self) {
-        auto status = self.Solve();
+      "_solve",
+      [](MPSolver& self, MPSolverParameters& params) {
+        auto status = self.Solve(params);
 
         if (status == MPSolver::ResultStatus::OPTIMAL) {
           return Symbol("optimal");

data/ext/or-tools/math_opt.cpp

@@ -0,0 +1,180 @@
+#include "absl/log/check.h"
+#include "absl/status/statusor.h"
+#include "ortools/base/init_google.h"
+#include "ortools/math_opt/cpp/math_opt.h"
+
+#include "ext.h"
+
+using operations_research::math_opt::LinearConstraint;
+using operations_research::math_opt::Model;
+using operations_research::math_opt::Solve;
+using operations_research::math_opt::SolveArguments;
+using operations_research::math_opt::SolveResult;
+using operations_research::math_opt::SolverType;
+using operations_research::math_opt::Termination;
+using operations_research::math_opt::TerminationReason;
+using operations_research::math_opt::Variable;
+
+namespace Rice::detail
+{
+  template<>
+  struct Type<SolverType>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
+
+  template<>
+  struct From_Ruby<SolverType>
+  {
+    static SolverType convert(VALUE x)
+    {
+      auto s = Symbol(x).str();
+      if (s == "gscip") {
+        return SolverType::kGscip;
+      } else if (s == "gurobi") {
+        return SolverType::kGurobi;
+      } else if (s == "glop") {
+        return SolverType::kGlop;
+      } else if (s == "cpsat") {
+        return SolverType::kCpSat;
+      } else if (s == "pdlp") {
+        return SolverType::kPdlp;
+      } else if (s == "glpk") {
+        return SolverType::kGlpk;
+      } else if (s == "ecos") {
+        return SolverType::kEcos;
+      } else if (s == "scs") {
+        return SolverType::kScs;
+      } else if (s == "highs") {
+        return SolverType::kHighs;
+      } else if (s == "santorini") {
+        return SolverType::kSantorini;
+      } else {
+        throw std::runtime_error("Unknown solver type: " + s);
+      }
+    }
+  };
+}
+
+void init_math_opt(Rice::Module& m) {
+  auto mathopt = Rice::define_module_under(m, "MathOpt");
+
+  Rice::define_class_under<Variable>(mathopt, "Variable")
+    .define_method("id", &Variable::id)
+    .define_method("name", &Variable::name)
+    .define_method(
+      "_eql?",
+      [](Variable& self, Variable &other) {
+        return (bool) (self == other);
+      });
+
+  Rice::define_class_under<LinearConstraint>(mathopt, "LinearConstraint");
+
+  Rice::define_class_under<Termination>(mathopt, "Termination")
+    .define_method(
+      "reason",
+      [](Termination& self) {
+        auto reason = self.reason;
+
+        if (reason == TerminationReason::kOptimal) {
+          return Rice::Symbol("optimal");
+        } else if (reason == TerminationReason::kInfeasible) {
+          return Rice::Symbol("infeasible");
+        } else if (reason == TerminationReason::kUnbounded) {
+          return Rice::Symbol("unbounded");
+        } else if (reason == TerminationReason::kInfeasibleOrUnbounded) {
+          return Rice::Symbol("infeasible_or_unbounded");
+        } else if (reason == TerminationReason::kImprecise) {
+          return Rice::Symbol("imprecise");
+        } else if (reason == TerminationReason::kFeasible) {
+          return Rice::Symbol("feasible");
+        } else if (reason == TerminationReason::kNoSolutionFound) {
+          return Rice::Symbol("no_solution_found");
+        } else if (reason == TerminationReason::kNumericalError) {
+          return Rice::Symbol("numerical_error");
+        } else if (reason == TerminationReason::kOtherError) {
+          return Rice::Symbol("other");
+        } else {
+          throw std::runtime_error("Unknown termination reason");
+        }
+      });
+
+  Rice::define_class_under<SolveResult>(mathopt, "SolveResult")
+    .define_method(
+      "termination",
+      [](SolveResult& self) {
+        return self.termination;
+      })
+    .define_method(
+      "objective_value",
+      [](SolveResult& self) {
+        return self.objective_value();
+      })
+    .define_method(
+      "variable_values",
+      [](SolveResult& self) {
+        Rice::Hash map;
+        for (auto& [k, v] : self.variable_values()) {
+          map[k] = v;
+        }
+        return map;
+      });
+
+  Rice::define_class_under<Model>(mathopt, "Model")
+    .define_constructor(Rice::Constructor<Model, std::string>())
+    .define_method("add_variable", &Model::AddContinuousVariable)
+    .define_method("add_integer_variable", &Model::AddIntegerVariable)
+    .define_method("add_binary_variable", &Model::AddBinaryVariable)
+    .define_method(
+      "_add_linear_constraint",
+      [](Model& self) {
+        return self.AddLinearConstraint();
+      })
+    .define_method(
+      "_set_upper_bound",
+      [](Model& self, LinearConstraint constraint, double upper_bound) {
+        self.set_upper_bound(constraint, upper_bound);
+      })
+    .define_method(
+      "_set_lower_bound",
+      [](Model& self, LinearConstraint constraint, double upper_bound) {
+        self.set_lower_bound(constraint, upper_bound);
+      })
+    .define_method("_set_coefficient", &Model::set_coefficient)
+    .define_method(
+      "_set_objective_coefficient",
+      [](Model& self, Variable variable, double value) {
+        self.set_objective_coefficient(variable, value);
+      })
+    .define_method("_clear_objective", &Model::clear_objective)
+    .define_method(
+      "_set_objective_offset",
+      [](Model& self, double value) {
+        self.set_objective_offset(value);
+      })
+    .define_method(
+      "_set_maximize",
+      [](Model& self) {
+        self.set_maximize();
+      })
+    .define_method(
+      "_set_minimize",
+      [](Model& self) {
+        self.set_minimize();
+      })
+    .define_method(
+      "_solve",
+      [](Model& self, SolverType solver_type) {
+        SolveArguments args;
+        auto result = Solve(self, solver_type, args);
+
+        if (!result.ok()) {
+          throw std::invalid_argument(std::string{result.status().message()});
+        }
+
+        return *result;
+      });
+}