or-tools 0.5.0 → 0.5.4

data/ext/or-tools/routing.cpp

@@ -1,19 +1,17 @@
 #include <ortools/constraint_solver/routing.h>
 #include <ortools/constraint_solver/routing_parameters.h>
 
-#include <rice/Array.hpp>
-#include <rice/Class.hpp>
-#include <rice/Constructor.hpp>
-#include <rice/Module.hpp>
-#include <rice/String.hpp>
-#include <rice/Symbol.hpp>
+#include "ext.h"
 
+using operations_research::Assignment;
+using operations_research::ConstraintSolverParameters;
 using operations_research::DefaultRoutingSearchParameters;
 using operations_research::FirstSolutionStrategy;
 using operations_research::LocalSearchMetaheuristic;
 using operations_research::RoutingDimension;
 using operations_research::RoutingIndexManager;
 using operations_research::RoutingModel;
+using operations_research::RoutingModelParameters;
 using operations_research::RoutingNodeIndex;
 using operations_research::RoutingSearchParameters;
 
@@ -24,99 +22,50 @@ using Rice::Object;
 using Rice::String;
 using Rice::Symbol;
 
-template<>
-inline
-RoutingNodeIndex from_ruby<RoutingNodeIndex>(Object x)
+namespace Rice::detail
 {
-  const RoutingNodeIndex index{from_ruby<int>(x)};
-  return index;
-}
-
-template<>
-inline
-Object to_ruby<RoutingNodeIndex>(RoutingNodeIndex const &x)
-{
-  return to_ruby<int>(x.value());
-}
-
-std::vector<RoutingNodeIndex> nodeIndexVector(Array x) {
-  std::vector<RoutingNodeIndex> res;
-  for (auto const& v : x) {
-    res.push_back(from_ruby<RoutingNodeIndex>(v));
-  }
-  return res;
-}
+  template<>
+  struct Type<RoutingNodeIndex>
+  {
+    static bool verify()
+    {
+      return true;
+    }
+  };
 
-// need a wrapper class due to const
-class Assignment {
-  const operations_research::Assignment* self;
+  template<>
+  class From_Ruby<RoutingNodeIndex>
+  {
   public:
-    Assignment(const operations_research::Assignment* v) {
-      self = v;
-    }
-    int64_t ObjectiveValue() {
-      return self->ObjectiveValue();
-    }
-    int64_t Value(const operations_research::IntVar* const var) const {
-      return self->Value(var);
-    }
-    int64_t Min(const operations_research::IntVar* const var) const {
-      return self->Min(var);
-    }
-    int64_t Max(const operations_research::IntVar* const var) const {
-      return self->Max(var);
+    RoutingNodeIndex convert(VALUE x)
+    {
+      const RoutingNodeIndex index{From_Ruby<int>().convert(x)};
+      return index;
     }
-};
-
-Class rb_cIntVar;
-Class rb_cIntervalVar;
-Class rb_cRoutingDimension;
-Class rb_cConstraint;
-Class rb_cSolver2;
-
-template<>
-inline
-Object to_ruby<operations_research::IntVar*>(operations_research::IntVar* const &x)
-{
-  return Rice::Data_Object<operations_research::IntVar>(x, rb_cIntVar, nullptr, nullptr);
-}
-
-template<>
-inline
-Object to_ruby<operations_research::IntervalVar*>(operations_research::IntervalVar* const &x)
-{
-  return Rice::Data_Object<operations_research::IntervalVar>(x, rb_cIntervalVar, nullptr, nullptr);
-}
-
-template<>
-inline
-Object to_ruby<RoutingDimension*>(RoutingDimension* const &x)
-{
-  return Rice::Data_Object<RoutingDimension>(x, rb_cRoutingDimension, nullptr, nullptr);
-}
+  };
 
-template<>
-inline
-Object to_ruby<operations_research::Constraint*>(operations_research::Constraint* const &x)
-{
-  return Rice::Data_Object<operations_research::Constraint>(x, rb_cConstraint, nullptr, nullptr);
-}
-
-template<>
-inline
-Object to_ruby<operations_research::Solver*>(operations_research::Solver* const &x)
-{
-  return Rice::Data_Object<operations_research::Solver>(x, rb_cSolver2, nullptr, nullptr);
+  template<>
+  class To_Ruby<RoutingNodeIndex>
+  {
+  public:
+    VALUE convert(RoutingNodeIndex const & x)
+    {
+      return To_Ruby<int>().convert(x.value());
+    }
+  };
 }
 
 void init_routing(Rice::Module& m) {
-  m.define_singleton_method("default_routing_search_parameters", &DefaultRoutingSearchParameters);
+  auto rb_cRoutingSearchParameters = Rice::define_class_under<RoutingSearchParameters>(m, "RoutingSearchParameters");
+  auto rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "IntVar");
 
-  Rice::define_class_under<RoutingSearchParameters>(m, "RoutingSearchParameters")
+  m.define_singleton_function("default_routing_search_parameters", &DefaultRoutingSearchParameters);
+
+  rb_cRoutingSearchParameters
     .define_method(
       "first_solution_strategy=",
-      *[](RoutingSearchParameters& self, Symbol value) {
-        std::string s = Symbol(value).str();
+      [](RoutingSearchParameters& self, Symbol value) {
+        auto s = Symbol(value).str();
 
         FirstSolutionStrategy::Value v;
         if (s == "path_cheapest_arc") {
@@ -155,8 +104,8 @@ void init_routing(Rice::Module& m) {
       })
     .define_method(
       "local_search_metaheuristic=",
-      *[](RoutingSearchParameters& self, Symbol value) {
-        std::string s = Symbol(value).str();
+      [](RoutingSearchParameters& self, Symbol value) {
+        auto s = Symbol(value).str();
 
         LocalSearchMetaheuristic::Value v;
         if (s == "guided_local_search") {
@@ -175,35 +124,35 @@ void init_routing(Rice::Module& m) {
       })
     .define_method(
       "log_search=",
-      *[](RoutingSearchParameters& self, bool value) {
+      [](RoutingSearchParameters& self, bool value) {
         self.set_log_search(value);
       })
     .define_method(
       "solution_limit=",
-      *[](RoutingSearchParameters& self, int64_t value) {
+      [](RoutingSearchParameters& self, int64_t value) {
         self.set_solution_limit(value);
       })
     .define_method(
       "time_limit=",
-      *[](RoutingSearchParameters& self, int64_t value) {
+      [](RoutingSearchParameters& self, int64_t value) {
         self.mutable_time_limit()->set_seconds(value);
       })
     .define_method(
       "lns_time_limit=",
-      *[](RoutingSearchParameters& self, int64_t value) {
+      [](RoutingSearchParameters& self, int64_t value) {
         self.mutable_lns_time_limit()->set_seconds(value);
       });
 
   Rice::define_class_under<RoutingIndexManager>(m, "RoutingIndexManager")
-    .define_singleton_method(
+    .define_singleton_function(
       "_new_depot",
-      *[](int num_nodes, int num_vehicles, RoutingNodeIndex depot) {
+      [](int num_nodes, int num_vehicles, RoutingNodeIndex depot) {
         return RoutingIndexManager(num_nodes, num_vehicles, depot);
       })
-    .define_singleton_method(
+    .define_singleton_function(
       "_new_starts_ends",
-      *[](int num_nodes, int num_vehicles, Array starts, Array ends) {
-        return RoutingIndexManager(num_nodes, num_vehicles, nodeIndexVector(starts), nodeIndexVector(ends));
+      [](int num_nodes, int num_vehicles, std::vector<RoutingNodeIndex> starts, std::vector<RoutingNodeIndex> ends) {
+        return RoutingIndexManager(num_nodes, num_vehicles, starts, ends);
       })
     .define_method("index_to_node", &RoutingIndexManager::IndexToNode)
     .define_method("node_to_index", &RoutingIndexManager::NodeToIndex);
@@ -215,29 +164,55 @@ void init_routing(Rice::Module& m) {
     .define_method("max", &Assignment::Max);
 
   // not to be confused with operations_research::sat::IntVar
-  rb_cIntVar = Rice::define_class_under<operations_research::IntVar>(m, "IntVar")
+  rb_cIntVar
+    .define_method("var?", &operations_research::IntVar::IsVar)
+    .define_method("value", &operations_research::IntVar::Value)
+    .define_method("remove_value", &operations_research::IntVar::RemoveValue)
+    .define_method("remove_interval", &operations_research::IntVar::RemoveInterval)
+    .define_method("remove_values", &operations_research::IntVar::RemoveValues)
+    .define_method("set_values", &operations_research::IntVar::SetValues)
+    .define_method("size", &operations_research::IntVar::Size)
+    .define_method("contains", &operations_research::IntVar::Contains)
+    .define_method("old_min", &operations_research::IntVar::OldMin)
+    .define_method("old_max", &operations_research::IntVar::OldMax)
     .define_method(
       "set_range",
-      *[](operations_research::IntVar& self, int64_t new_min, int64_t new_max) {
+      [](operations_research::IntVar& self, int64_t new_min, int64_t new_max) {
         self.SetRange(new_min, new_max);
       });
 
-  rb_cIntervalVar = Rice::define_class_under<operations_research::IntervalVar>(m, "IntervalVar");
+  Rice::define_class_under<operations_research::IntervalVar>(m, "IntervalVar")
+    .define_method("start_min", &operations_research::IntervalVar::StartMin)
+    .define_method("start_max", &operations_research::IntervalVar::StartMax)
+    .define_method("set_start_min", &operations_research::IntervalVar::SetStartMin)
+    .define_method("set_start_max", &operations_research::IntervalVar::SetStartMax)
+    .define_method("set_start_range", &operations_research::IntervalVar::SetStartRange)
+    .define_method("old_start_min", &operations_research::IntervalVar::OldStartMin)
+    .define_method("old_start_max", &operations_research::IntervalVar::OldStartMax)
+    .define_method("end_min", &operations_research::IntervalVar::EndMin)
+    .define_method("end_max", &operations_research::IntervalVar::EndMax)
+    .define_method("set_end_min", &operations_research::IntervalVar::SetEndMin)
+    .define_method("set_end_max", &operations_research::IntervalVar::SetEndMax)
+    .define_method("set_end_range", &operations_research::IntervalVar::SetEndRange)
+    .define_method("old_end_min", &operations_research::IntervalVar::OldEndMin)
+    .define_method("old_end_max", &operations_research::IntervalVar::OldEndMax);
 
-  rb_cRoutingDimension = Rice::define_class_under<RoutingDimension>(m, "RoutingDimension")
+  Rice::define_class_under<RoutingDimension>(m, "RoutingDimension")
     .define_method("global_span_cost_coefficient=", &RoutingDimension::SetGlobalSpanCostCoefficient)
     .define_method("cumul_var", &RoutingDimension::CumulVar);
 
-  rb_cConstraint = Rice::define_class_under<operations_research::Constraint>(m, "Constraint");
+  Rice::define_class_under<operations_research::Constraint>(m, "Constraint")
+    .define_method("post", &operations_research::Constraint::Post)
+    .define_method("debug_string", &operations_research::Constraint::DebugString);
 
-  rb_cSolver2 = Rice::define_class_under<operations_research::Solver>(m, "Solver2")
+  Rice::define_class_under<operations_research::Solver>(m, "Solver2")
     .define_method(
       "add",
-      *[](operations_research::Solver& self, Object o) {
+      [](operations_research::Solver& self, Object o) {
         operations_research::Constraint* constraint;
         if (o.respond_to("left")) {
-          operations_research::IntExpr* left(from_ruby<operations_research::IntVar*>(o.call("left")));
-          operations_research::IntExpr* right(from_ruby<operations_research::IntVar*>(o.call("right")));
+          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();
           if (op == "==") {
             constraint = self.MakeEquality(left, right);
@@ -247,54 +222,69 @@ void init_routing(Rice::Module& m) {
             throw std::runtime_error("Unknown operator");
           }
         } else {
-          constraint = from_ruby<operations_research::Constraint*>(o);
+          constraint = Rice::detail::From_Ruby<operations_research::Constraint*>().convert(o);
         }
         self.AddConstraint(constraint);
       })
     .define_method(
       "fixed_duration_interval_var",
-      *[](operations_research::Solver& self, operations_research::IntVar* const start_variable, int64_t duration, const std::string& name) {
+      [](operations_research::Solver& self, operations_research::IntVar* const start_variable, int64_t duration, const std::string& name) {
         return self.MakeFixedDurationIntervalVar(start_variable, duration, name);
       })
     .define_method(
       "cumulative",
-      *[](operations_research::Solver& self, Array rb_intervals, Array rb_demands, int64_t capacity, const std::string& name) {
-        std::vector<operations_research::IntervalVar*> intervals;
-        for (std::size_t i = 0; i < rb_intervals.size(); ++i) {
-          intervals.push_back(from_ruby<operations_research::IntervalVar*>(rb_intervals[i]));
-        }
+      [](operations_research::Solver& self, std::vector<operations_research::IntervalVar*> intervals, std::vector<int64_t> demands, int64_t capacity, const std::string& name) {
+        return self.MakeCumulative(intervals, demands, capacity, name);
+      });
 
-        std::vector<int64_t> demands;
-        for (std::size_t i = 0; i < rb_demands.size(); ++i) {
-          demands.push_back(from_ruby<int64_t>(rb_demands[i]));
-        }
+  Rice::define_class_under<ConstraintSolverParameters>(m, "ConstraintSolverParameters")
+    .define_method(
+      "trace_propagation=",
+      [](ConstraintSolverParameters& self, bool value) {
+        self.set_trace_propagation(value);
+      })
+    .define_method(
+      "trace_search=",
+      [](ConstraintSolverParameters& self, bool value) {
+        self.set_trace_search(value);
+      });
 
-        return self.MakeCumulative(intervals, demands, capacity, name);
+  Rice::define_class_under<RoutingModelParameters>(m, "RoutingModelParameters")
+    .define_method(
+      "solver_parameters",
+      [](RoutingModelParameters& self) {
+        return self.mutable_solver_parameters();
       });
 
+  m.define_singleton_function(
+    "default_routing_model_parameters",
+    []() {
+      return operations_research::DefaultRoutingModelParameters();
+    });
+
   Rice::define_class_under<RoutingModel>(m, "RoutingModel")
-    .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager>())
+    .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager, RoutingModelParameters>(), Rice::Arg("index_manager"), Rice::Arg("parameters") = operations_research::DefaultRoutingModelParameters())
     .define_method(
       "register_transit_callback",
-      *[](RoutingModel& self, Object callback) {
+      [](RoutingModel& self, Object callback) {
         return self.RegisterTransitCallback(
           [callback](int64_t from_index, int64_t to_index) -> int64_t {
-            return from_ruby<int64_t>(callback.call("call", from_index, to_index));
+            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
           }
         );
       })
     .define_method(
       "register_unary_transit_callback",
-      *[](RoutingModel& self, Object callback) {
+      [](RoutingModel& self, Object callback) {
         return self.RegisterUnaryTransitCallback(
           [callback](int64_t from_index) -> int64_t {
-            return from_ruby<int64_t>(callback.call("call", from_index));
+            return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
           }
         );
       })
     .define_method("depot", &RoutingModel::GetDepot)
     .define_method("size", &RoutingModel::Size)
-    .define_method("status", *[](RoutingModel& self) {
+    .define_method("status", [](RoutingModel& self) {
         auto status = self.status();
 
         if (status == RoutingModel::ROUTING_NOT_SOLVED) {
@@ -320,29 +310,17 @@ void init_routing(Rice::Module& m) {
     .define_method("add_dimension", &RoutingModel::AddDimension)
     .define_method(
       "add_dimension_with_vehicle_capacity",
-      *[](RoutingModel& self, int evaluator_index, int64_t slack_max, Array vc, bool fix_start_cumul_to_zero, const std::string& name) {
-        std::vector<int64_t> vehicle_capacities;
-        for (std::size_t i = 0; i < vc.size(); ++i) {
-          vehicle_capacities.push_back(from_ruby<int64_t>(vc[i]));
-        }
+      [](RoutingModel& self, int evaluator_index, int64_t slack_max, std::vector<int64_t> vehicle_capacities, bool fix_start_cumul_to_zero, const std::string& name) {
         self.AddDimensionWithVehicleCapacity(evaluator_index, slack_max, vehicle_capacities, fix_start_cumul_to_zero, name);
       })
     .define_method(
       "add_dimension_with_vehicle_transits",
-      *[](RoutingModel& self, Array rb_indices, int64_t slack_max, int64_t capacity, bool fix_start_cumul_to_zero, const std::string& name) {
-        std::vector<int> evaluator_indices;
-        for (std::size_t i = 0; i < rb_indices.size(); ++i) {
-          evaluator_indices.push_back(from_ruby<int>(rb_indices[i]));
-        }
+      [](RoutingModel& self, std::vector<int> evaluator_indices, int64_t slack_max, int64_t capacity, bool fix_start_cumul_to_zero, const std::string& name) {
         self.AddDimensionWithVehicleTransits(evaluator_indices, slack_max, capacity, fix_start_cumul_to_zero, name);
       })
     .define_method(
       "add_disjunction",
-      *[](RoutingModel& self, Array rb_indices, int64_t penalty) {
-        std::vector<int64_t> indices;
-        for (std::size_t i = 0; i < rb_indices.size(); ++i) {
-          indices.push_back(from_ruby<int64_t>(rb_indices[i]));
-        }
+      [](RoutingModel& self, std::vector<int64_t> indices, int64_t penalty) {
         self.AddDisjunction(indices, penalty);
       })
     .define_method("add_pickup_and_delivery", &RoutingModel::AddPickupAndDelivery)
@@ -360,9 +338,7 @@ void init_routing(Rice::Module& m) {
     .define_method("add_variable_minimized_by_finalizer", &RoutingModel::AddVariableMinimizedByFinalizer)
     .define_method(
       "solve_with_parameters",
-      *[](RoutingModel& self, const RoutingSearchParameters& search_parameters) {
-        auto assignment = self.SolveWithParameters(search_parameters);
-        // std::cout << assignment->DebugString();
-        return (Assignment) assignment;
+      [](RoutingModel& self, const RoutingSearchParameters& search_parameters) {
+        return self.SolveWithParameters(search_parameters);
       });
 }

data/ext/or-tools/vendor.rb

@@ -3,29 +3,32 @@ require "fileutils"
 require "net/http"
 require "tmpdir"
 
-version = "9.0.9048"
+version = "9.1.9490"
 
 if RbConfig::CONFIG["host_os"] =~ /darwin/i
-  filename = "or-tools_MacOsX-11.2.3_v#{version}.tar.gz"
-  checksum = "adf73a00d4ec49558b67be5ce3cfc8f30268da2253b35feb11d0d40700550bf6"
+  filename = "or-tools_MacOsX-11.6_v#{version}.tar.gz"
+  checksum = "97a2b113806c1b2d17f9b3f30571c9ee82722eb22e06bd124d94118f3a84da2c"
 else
   os = %x[lsb_release -is].chomp rescue nil
   os_version = %x[lsb_release -rs].chomp rescue nil
   if os == "Ubuntu" && os_version == "20.04"
-    filename = "or-tools_ubuntu-20.04_v#{version}.tar.gz"
-    checksum = "5565343c1c310d2885a40ce850ae7e3468299b3fee97ae8eed8425ce06bd4960"
+    filename = "or-tools_amd64_ubuntu-20.04_v#{version}.tar.gz"
+    checksum = "cf82e5c343ab74bef320b240a2c3937b07df945e60b91bbc771b477c0856c1bd"
   elsif os == "Ubuntu" && os_version == "18.04"
-    filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
-    checksum = "08cf548d0179f7fa814bb7458be94cd1b8a3de14985e6a9faf6118a1d8571539"
+    filename = "or-tools_amd64_ubuntu-18.04_v#{version}.tar.gz"
+    checksum = "b641677cc3e1095b7e8efd9c5c948698f5e2c238d10d06f1abf0b0ee240addf2"
+  elsif os == "Debian" && os_version == "11"
+    filename = "or-tools_amd64_debian-11_v#{version}.tar.gz"
+    checksum = "de7e63988fc62c64718d8f8f37f98a1c589c89ebc46fc1f378da4b66ad385ff1"
   elsif os == "Debian" && os_version == "10"
-    filename = "or-tools_debian-10_v#{version}.tar.gz"
-    checksum = "063fb1d8765ae23b0bb25b9c561e904532713416fe0458f7db45a0f72190eb50"
+    filename = "or-tools_amd64_debian-10_v#{version}.tar.gz"
+    checksum = "80411caeccac079fe8ee6018ceae844f5f04d2deecacd3406d51354dea5435e4"
   elsif os == "CentOS" && os_version == "8"
-    filename = "or-tools_centos-8_v#{version}.tar.gz"
-    checksum = "c98212ed4fc699d8ae70c1f53cd1d8dacd28e52970336fab5b86dedf7406f215"
+    filename = "or-tools_amd64_centos-8_v#{version}.tar.gz"
+    checksum = "fe23b04dd7a20c5902fbf89bb626080296489a05e0bfb39225e71be5e9cee1ac"
   elsif os == "CentOS" && os_version == "7"
-    filename = "or-tools_centos-7_v#{version}.tar.gz"
-    checksum = "b992bda4614bbc703583b0e9edcd2ade54bacfb9909399b20c8aa95ff7197d68"
+    filename = "or-tools_amd64_centos-7_v#{version}.tar.gz"
+    checksum = "ef48363b27591c25f8702e085024aa7b5f5190ad94c859481116538f04c124f9"
   else
     platform =
       if Gem.win_platform?

data/lib/or_tools/cp_solver.rb

@@ -6,8 +6,8 @@ module ORTools
 
     def_delegators :@response, :objective_value, :num_conflicts, :num_branches, :wall_time
 
-    def solve(model)
-      @response = _solve(model, parameters)
+    def solve(model, observer = nil)
+      @response = _solve(model, parameters, observer)
       @response.status
     end
 
@@ -20,13 +20,19 @@ module ORTools
     end
 
     def solve_with_solution_callback(model, observer)
-      @response = _solve_with_observer(model, parameters, observer, false)
-      @response.status
+      warn "[or-tools] solve_with_solution_callback is deprecated; use solve(model, callback)"
+      solve(model, observer)
     end
 
     def search_for_all_solutions(model, observer)
-      @response = _solve_with_observer(model, parameters, observer, true)
-      @response.status
+      warn "[or-tools] search_for_all_solutions is deprecated; use solve() with solver.parameters.enumerate_all_solutions = true"
+      previous_value = parameters.enumerate_all_solutions
+      begin
+        parameters.enumerate_all_solutions = true
+        solve(model, observer)
+      ensure
+        parameters.enumerate_all_solutions = previous_value
+      end
     end
 
     def sufficient_assumptions_for_infeasibility

data/lib/or_tools/seating.rb

@@ -78,7 +78,7 @@ module ORTools
 
       # min known neighbors rule
       same_table_by_person = Hash.new { |hash, key| hash[key] = [] }
-      same_table.each do |(g1, g2, t), v|
+      same_table.each do |(g1, g2, _t), v|
         next unless @connections_for[g1][g2]
         same_table_by_person[g1] << v
         same_table_by_person[g2] << v

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.5.0"
+  VERSION = "0.5.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.4
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-30 00:00:00.000000000 Z
+date: 2021-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: 4.0.2
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '3'
+        version: 4.0.2
 description:
 email: andrew@ankane.org
 executables: []
@@ -39,6 +39,7 @@ files:
 - ext/or-tools/bin_packing.cpp
 - ext/or-tools/constraint.cpp
 - ext/or-tools/ext.cpp
+- ext/or-tools/ext.h
 - ext/or-tools/extconf.rb
 - ext/or-tools/linear.cpp
 - ext/or-tools/network_flows.cpp
@@ -86,7 +87,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Operations research tools for Ruby