or-tools 0.13.1 → 0.14.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4863311462c6b8ec192b18548667397398e2b7f183c01922fdfe3d464157a9fc
-  data.tar.gz: 2e0ad658ab77b7c18aa449fad095d0dfa6c098b8bae80fd7d1ea1dbcae4b292f
+  metadata.gz: 29ccd0801b240802b1a4c5b3344aeb33feff36381aa3bc714c369ae1ea4912ea
+  data.tar.gz: 3d64b0da4320c77545b75d4830ee23040c5bb3d4eab568db23ab425e9ec0a3dd
 SHA512:
-  metadata.gz: 6135045892abd2f572bd40603d36024e3984f7dfec10b1c40cc49dbc21c381d4b81c3e2cbe795f51fe52ecc88b579fa15b99cb8455872459649865be14031d4b
-  data.tar.gz: e0df2a74200821b3d55f78cdf764d2720724449931298a2bb902c395587cd0b7117094b629e226273c65f5492b4846f2d7a26f753eb1d126088905a8ecad6354
+  metadata.gz: 660915a87810919150acf5c5e5a67ae51c775a4df66a99293f3f58b6520615fd5519b7298a8d0f1d1127488faffaba8f326c7cd1740ff6d3ea2636a5e5e16062
+  data.tar.gz: 760fc1cf72fe774787b2ae0a28f6b1f3a7f8a954af855a86d7061945e112f88408cbf160117832568878f01bcbac86d8a6078b6c174778be8e51b025d04d6f8f

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 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)
@@ -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,58 +44,27 @@ 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) {
@@ -119,13 +88,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 +404,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,8 +2,6 @@
 
 #include "ext.h"
 
-using operations_research::LinearExpr;
-using operations_research::LinearRange;
 using operations_research::MPConstraint;
 using operations_research::MPObjective;
 using operations_research::MPSolver;
@@ -45,12 +43,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);
 
@@ -66,7 +59,15 @@ void init_linear(Rice::Module& m) {
     .define_method("set_minimization", &MPObjective::SetMinimization);
 
   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) {

data/ext/or-tools/math_opt.cpp

@@ -0,0 +1,179 @@
+#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(
+      "_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;
+      });
+}

data/ext/or-tools/routing.cpp

@@ -56,22 +56,9 @@ namespace Rice::detail
   };
 }
 
-namespace Rice::detail
-{
-  template<class T, class U>
-  class To_Ruby<std::pair<T, U>>
-  {
-  public:
-    VALUE convert(std::pair<T, U> const & x)
-    {
-      return rb_ary_new3(2, To_Ruby<T>().convert(x.first), To_Ruby<U>().convert(x.second));
-    }
-  };
-}
-
 void init_routing(Rice::Module& m) {
   auto rb_cRoutingSearchParameters = Rice::define_class_under<RoutingSearchParameters>(m, "RoutingSearchParameters");
-  auto rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "IntVar");
+  auto rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "RoutingIntVar");
 
   m.define_singleton_function("default_routing_search_parameters", &DefaultRoutingSearchParameters);
 
@@ -213,7 +200,6 @@ void init_routing(Rice::Module& m) {
 
   Rice::define_class_under<RoutingDimension>(m, "RoutingDimension")
     .define_method("transit_value", &RoutingDimension::GetTransitValue)
-    // TODO GetTransitValueFromClass
     .define_method("cumul_var", &RoutingDimension::CumulVar)
     .define_method("transit_var", &RoutingDimension::TransitVar)
     .define_method("fixed_transit_var", &RoutingDimension::FixedTransitVar)
@@ -239,7 +225,7 @@ void init_routing(Rice::Module& m) {
     .define_method("post", &operations_research::Constraint::Post)
     .define_method("debug_string", &operations_research::Constraint::DebugString);
 
-  Rice::define_class_under<operations_research::Solver>(m, "Solver2")
+  Rice::define_class_under<operations_research::Solver>(m, "RoutingSolver")
     .define_method(
       "add",
       [](operations_research::Solver& self, Object o) {
@@ -247,7 +233,7 @@ void init_routing(Rice::Module& m) {
         if (o.respond_to("left")) {
           operations_research::IntExpr* left(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("left")));
           operations_research::IntExpr* right(Rice::detail::From_Ruby<operations_research::IntVar*>().convert(o.call("right")));
-          auto op = o.call("operator").to_s().str();
+          auto op = o.call("op").to_s().str();
           if (op == "==") {
             constraint = self.MakeEquality(left, right);
           } else if (op == "<=") {
@@ -304,8 +290,13 @@ void init_routing(Rice::Module& m) {
     .define_method(
       "register_unary_transit_callback",
       [](RoutingModel& self, Object callback) {
+        // TODO guard callback?
         return self.RegisterUnaryTransitCallback(
           [callback](int64_t from_index) -> int64_t {
+            if (!ruby_native_thread_p()) {
+              throw std::runtime_error("Non-Ruby thread");
+            }
+
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
           }
         );
@@ -314,8 +305,13 @@ void init_routing(Rice::Module& m) {
     .define_method(
       "register_transit_callback",
       [](RoutingModel& self, Object callback) {
+        // TODO guard callback?
         return self.RegisterTransitCallback(
           [callback](int64_t from_index, int64_t to_index) -> int64_t {
+            if (!ruby_native_thread_p()) {
+              throw std::runtime_error("Non-Ruby thread");
+            }
+
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
           }
         );
@@ -328,13 +324,8 @@ void init_routing(Rice::Module& m) {
     .define_method("add_constant_dimension", &RoutingModel::AddConstantDimension)
     .define_method("add_vector_dimension", &RoutingModel::AddVectorDimension)
     .define_method("add_matrix_dimension", &RoutingModel::AddMatrixDimension)
-    // TODO AddDimensionDependentDimensionWithVehicleCapacity
-    // .define_method("make_path_spans_and_total_slacks", &RoutingModel::MakePathSpansAndTotalSlacks)
     .define_method("all_dimension_names", &RoutingModel::GetAllDimensionNames)
-    // .define_method("dimensions", &RoutingModel::GetDimensions)
-    // .define_method("dimensions_with_soft_or_span_costs", &RoutingModel::GetDimensionsWithSoftOrSpanCosts)
     .define_method("dimension?", &RoutingModel::HasDimension)
-    // .define_method("dimension_or_die", &RoutingModel::GetDimensionOrDie)
     .define_method("mutable_dimension", &RoutingModel::GetMutableDimension)
     .define_method("set_primary_constrained_dimension", &RoutingModel::SetPrimaryConstrainedDimension)
     .define_method("primary_constrained_dimension", &RoutingModel::GetPrimaryConstrainedDimension)
@@ -373,9 +364,6 @@ void init_routing(Rice::Module& m) {
         }
         return positions;
       })
-    // TODO SetPickupAndDeliveryPolicyOfAllVehicles
-    // TODO SetPickupAndDeliveryPolicyOfVehicle
-    // TODO GetPickupAndDeliveryPolicyOfVehicle
     .define_method("num_of_singleton_nodes", &RoutingModel::GetNumOfSingletonNodes)
     .define_method("unperformed_penalty", &RoutingModel::UnperformedPenalty)
     .define_method("unperformed_penalty_or_value", &RoutingModel::UnperformedPenaltyOrValue)
@@ -444,8 +432,6 @@ void init_routing(Rice::Module& m) {
     .define_method("compact_and_check_assignment", &RoutingModel::CompactAndCheckAssignment)
     .define_method("add_to_assignment", &RoutingModel::AddToAssignment)
     .define_method("add_interval_to_assignment", &RoutingModel::AddIntervalToAssignment)
-    // TODO PackCumulsOfOptimizerDimensionsFromAssignment
-    // TODO AddLocalSearchFilter
     .define_method("start", &RoutingModel::Start)
     .define_method("end", &RoutingModel::End)
     .define_method("start?", &RoutingModel::IsStart)

data/lib/or-tools.rb

@@ -1,39 +1,50 @@
 # ext
 require "or_tools/ext"
 
-# modules
+# expressions
+require_relative "or_tools/expression"
 require_relative "or_tools/comparison"
-require_relative "or_tools/comparison_operators"
-require_relative "or_tools/bool_var"
 require_relative "or_tools/constant"
+require_relative "or_tools/product"
+require_relative "or_tools/variable"
+
+# bin packing
+require_relative "or_tools/knapsack_solver"
+
+# constraint
 require_relative "or_tools/cp_model"
 require_relative "or_tools/cp_solver"
 require_relative "or_tools/cp_solver_solution_callback"
-require_relative "or_tools/int_var"
-require_relative "or_tools/knapsack_solver"
-require_relative "or_tools/linear_constraint"
-require_relative "or_tools/linear_expr"
-require_relative "or_tools/mp_variable"
-require_relative "or_tools/product_cst"
-require_relative "or_tools/routing_index_manager"
-require_relative "or_tools/routing_model"
-require_relative "or_tools/sat_linear_expr"
-require_relative "or_tools/sat_int_var"
-require_relative "or_tools/solver"
-require_relative "or_tools/sum_array"
-require_relative "or_tools/version"
-
-# solution printers
 require_relative "or_tools/objective_solution_printer"
 require_relative "or_tools/var_array_solution_printer"
 require_relative "or_tools/var_array_and_objective_solution_printer"
 
+# linear
+require_relative "or_tools/solver"
+
+# math opt
+require_relative "or_tools/math_opt/model"
+require_relative "or_tools/math_opt/variable"
+
+# routing
+require_relative "or_tools/routing_index_manager"
+require_relative "or_tools/routing_model"
+
 # higher level interfaces
 require_relative "or_tools/basic_scheduler"
 require_relative "or_tools/seating"
 require_relative "or_tools/sudoku"
 require_relative "or_tools/tsp"
 
+# modules
+require_relative "or_tools/utils"
+require_relative "or_tools/version"
+
 module ORTools
   class Error < StandardError; end
+
+  # previous names
+  Solver2 = RoutingSolver
+  IntVar = RoutingIntVar
+  BoolVar = SatBoolVar
 end

data/lib/or_tools/comparison.rb

@@ -1,19 +1,16 @@
 module ORTools
   class Comparison
-    attr_reader :operator, :left, :right
+    attr_reader :left, :op, :right
 
-    def initialize(operator, left, right)
-      @operator = operator
-      @left = left
-      @right = right
-    end
-
-    def to_s
-      "#{left} #{operator} #{right}"
+    def initialize(left, op, right)
+      @left = Expression.to_expression(left)
+      @op = op
+      @right = Expression.to_expression(right)
     end
 
     def inspect
-      "#<#{self.class.name} #{to_s}>"
+      "#{@left.inspect} #{@op} #{@right.inspect}"
     end
+    alias_method :to_s, :inspect
   end
 end

data/lib/or_tools/constant.rb

@@ -1,23 +1,26 @@
 module ORTools
-  class Constant < LinearExpr
-    def initialize(val)
-      @val = val
+  class Constant < Expression
+    attr_reader :value
+
+    def initialize(value)
+      @value = value
     end
 
-    def to_s
-      @val.to_s
+    # simplify Ruby sum
+    def +(other)
+      @value == 0 ? other : super
     end
 
-    def add_self_to_coeff_map_or_stack(coeffs, multiplier, stack)
-      coeffs[OFFSET_KEY] += @val * multiplier
+    def inspect
+      @value.to_s
     end
-  end
 
-  class FakeMPVariableRepresentingTheConstantOffset
-    def solution_value
-      1
+    def -@
+      Constant.new(-value)
     end
-  end
 
-  OFFSET_KEY = FakeMPVariableRepresentingTheConstantOffset.new
+    def vars
+      @vars ||= []
+    end
+  end
 end