or-tools 0.14.0 → 0.14.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29ccd0801b240802b1a4c5b3344aeb33feff36381aa3bc714c369ae1ea4912ea
-  data.tar.gz: 3d64b0da4320c77545b75d4830ee23040c5bb3d4eab568db23ab425e9ec0a3dd
+  metadata.gz: f2974585825c8e1f3d50aabc494131861eef79c80468a889537f58b2dd3926be
+  data.tar.gz: 5f9b8fe4574a30ebea1fba0b53a91475683e68fe5e535ba99047a6f2b3a16173
 SHA512:
-  metadata.gz: 660915a87810919150acf5c5e5a67ae51c775a4df66a99293f3f58b6520615fd5519b7298a8d0f1d1127488faffaba8f326c7cd1740ff6d3ea2636a5e5e16062
-  data.tar.gz: 760fc1cf72fe774787b2ae0a28f6b1f3a7f8a954af855a86d7061945e112f88408cbf160117832568878f01bcbac86d8a6078b6c174778be8e51b025d04d6f8f
+  metadata.gz: 48fc84cebe3a922044a98909dd8b06d61712ea1bdf06014b99a0a92dd4406766facd99cd3f2c99425257642ef08ad5a489d9ee87f354cf7f5d16a3d7ff306d5e
+  data.tar.gz: 6edc981eb8b47f716f607be3e7c28a59c49076810a7fcbda7077fcc3a1abcf420fe58c17d372a40447f435e7abfd68879fc471b0c8c86afdd4d1610786b0489e

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## 0.14.2 (2025-02-10)
+
+- Fixed error with Rice 4.5
+
+## 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`

data/README.md

@@ -93,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
   }
@@ -112,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")}
 ]
 ```
 

data/ext/or-tools/bin_packing.cpp

@@ -13,16 +13,15 @@ namespace Rice::detail
   template<>
   struct Type<KnapsackSolver::SolverType>
   {
-    static bool verify()
-    {
-      return true;
-    }
+    static bool verify() { return true; }
   };
 
   template<>
   class From_Ruby<KnapsackSolver::SolverType>
   {
   public:
+    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+
     KnapsackSolver::SolverType convert(VALUE x)
     {
       auto s = Symbol(x).str();

data/ext/or-tools/constraint.cpp

@@ -32,16 +32,15 @@ namespace Rice::detail
   template<>
   struct Type<LinearExpr>
   {
-    static bool verify()
-    {
-      return true;
-    }
+    static bool verify() { return true; }
   };
 
   template<>
   class From_Ruby<LinearExpr>
   {
   public:
+    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+
     LinearExpr convert(VALUE v)
     {
       LinearExpr expr;
@@ -70,6 +69,7 @@ namespace Rice::detail
 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);
 

data/ext/or-tools/extconf.rb

@@ -9,7 +9,7 @@ $CXXFLAGS << " -Wall -Wextra"
 $CXXFLAGS << " -Wno-sign-compare -Wno-ignored-qualifiers -Wno-unused-parameter -Wno-missing-field-initializers"
 
 # hide Rice warnings
-$CXXFLAGS << " -Wno-implicit-fallthrough"
+$CXXFLAGS << " -Wno-unused-private-field -Wno-implicit-fallthrough"
 
 inc, lib = dir_config("or-tools")
 if inc || lib

data/ext/or-tools/linear.cpp

@@ -4,6 +4,7 @@
 
 using operations_research::MPConstraint;
 using operations_research::MPObjective;
+using operations_research::MPSolverParameters;
 using operations_research::MPSolver;
 using operations_research::MPVariable;
 
@@ -19,15 +20,14 @@ namespace Rice::detail
   template<>
   struct Type<MPSolver::OptimizationProblemType>
   {
-    static bool verify()
-    {
-      return true;
-    }
+    static bool verify() { return true; }
   };
 
   template<>
   struct From_Ruby<MPSolver::OptimizationProblemType>
   {
+    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+
     static MPSolver::OptimizationProblemType convert(VALUE x)
     {
       auto s = Symbol(x).str();
@@ -56,8 +56,112 @@ 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);
+        if (presolve == MPSolverParameters::PresolveValues::PRESOLVE_ON) {
+          return Rice::True;
+        } else if (presolve == MPSolverParameters::PresolveValues::PRESOLVE_OFF) {
+          return Rice::False;
+        } else {
+          return Rice::Nil;
+        }
+      })
+    .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);
+        if (incrementality == MPSolverParameters::IncrementalityValues::INCREMENTALITY_ON) {
+          return Rice::True;
+        } else if (incrementality == MPSolverParameters::IncrementalityValues::INCREMENTALITY_OFF) {
+          return Rice::False;
+        } else {
+          return Rice::Nil;
+        }
+      })
+    .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);
+        if (scaling == MPSolverParameters::ScalingValues::SCALING_ON) {
+          return Rice::True;
+        } else if (scaling == MPSolverParameters::ScalingValues::SCALING_OFF) {
+          return Rice::False;
+        } else {
+          return Rice::Nil;
+        }
+      });
+
   Rice::define_class_under<MPSolver>(m, "Solver")
     .define_singleton_function(
       "_new",
@@ -109,9 +213,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

@@ -20,15 +20,14 @@ namespace Rice::detail
   template<>
   struct Type<SolverType>
   {
-    static bool verify()
-    {
-      return true;
-    }
+    static bool verify() { return true; }
   };
 
   template<>
   struct From_Ruby<SolverType>
   {
+    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+
     static SolverType convert(VALUE x)
     {
       auto s = Symbol(x).str();
@@ -64,6 +63,7 @@ void init_math_opt(Rice::Module& m) {
 
   Rice::define_class_under<Variable>(mathopt, "Variable")
     .define_method("id", &Variable::id)
+    .define_method("name", &Variable::name)
     .define_method(
       "_eql?",
       [](Variable& self, Variable &other) {

data/ext/or-tools/routing.cpp

@@ -28,16 +28,15 @@ namespace Rice::detail
   template<>
   struct Type<RoutingNodeIndex>
   {
-    static bool verify()
-    {
-      return true;
-    }
+    static bool verify() { return true; }
   };
 
   template<>
   class From_Ruby<RoutingNodeIndex>
   {
   public:
+    Convertible is_convertible(VALUE value) { return Convertible::Cast; }
+
     RoutingNodeIndex convert(VALUE x)
     {
       const RoutingNodeIndex index{From_Ruby<int>().convert(x)};
@@ -285,7 +284,7 @@ void init_routing(Rice::Module& m) {
   Rice::define_class_under<RoutingModel::ResourceGroup>(m, "ResourceGroup");
 
   Rice::define_class_under<RoutingModel>(m, "RoutingModel")
-    .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager, RoutingModelParameters>(), Rice::Arg("index_manager"), Rice::Arg("parameters") = operations_research::DefaultRoutingModelParameters())
+    .define_constructor(Rice::Constructor<RoutingModel, RoutingIndexManager, RoutingModelParameters>(), Rice::Arg("_index_manager"), Rice::Arg("_parameters") = operations_research::DefaultRoutingModelParameters())
     .define_method("register_unary_transit_vector", &RoutingModel::RegisterUnaryTransitVector)
     .define_method(
       "register_unary_transit_callback",
@@ -300,7 +299,7 @@ void init_routing(Rice::Module& m) {
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index));
           }
         );
-      }, Rice::Arg("callback").keepAlive())
+      }, Rice::Arg("_callback").keepAlive())
     .define_method("register_transit_matrix", &RoutingModel::RegisterTransitMatrix)
     .define_method(
       "register_transit_callback",
@@ -315,7 +314,7 @@ void init_routing(Rice::Module& m) {
             return Rice::detail::From_Ruby<int64_t>().convert(callback.call("call", from_index, to_index));
           }
         );
-      }, Rice::Arg("callback").keepAlive())
+      }, Rice::Arg("_callback").keepAlive())
     .define_method("add_dimension", &RoutingModel::AddDimension)
     .define_method("add_dimension_with_vehicle_transits", &RoutingModel::AddDimensionWithVehicleTransits)
     .define_method("add_dimension_with_vehicle_capacity", &RoutingModel::AddDimensionWithVehicleCapacity)
@@ -332,7 +331,7 @@ void init_routing(Rice::Module& m) {
     .define_method("add_resource_group", &RoutingModel::AddResourceGroup)
     .define_method("dimension_resource_group_indices", &RoutingModel::GetDimensionResourceGroupIndices)
     .define_method("dimension_resource_group_index", &RoutingModel::GetDimensionResourceGroupIndex)
-    .define_method("add_disjunction", &RoutingModel::AddDisjunction, Rice::Arg("indices"), Rice::Arg("penalty"), Rice::Arg("max_cardinality") = (int64_t)1)
+    .define_method("add_disjunction", &RoutingModel::AddDisjunction, Rice::Arg("_indices"), Rice::Arg("_penalty"), Rice::Arg("_max_cardinality") = (int64_t)1)
     .define_method("disjunction_indices", &RoutingModel::GetDisjunctionIndices)
     .define_method("disjunction_penalty", &RoutingModel::GetDisjunctionPenalty)
     .define_method("disjunction_max_cardinality", &RoutingModel::GetDisjunctionMaxCardinality)

data/lib/or_tools/solver.rb

@@ -34,6 +34,11 @@ module ORTools
       objective.set_minimization
     end
 
+    def solve(parameters = nil)
+      parameters ||= MPSolverParameters.new
+      _solve(parameters)
+    end
+
     private
 
     def set_objective(expr)

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.14.0"
+  VERSION = "0.14.2"
 end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.14.0
+  version: 0.14.2
 platform: ruby
 authors:
 - Andrew Kane
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-22 00:00:00.000000000 Z
+date: 2025-02-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -16,15 +15,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.3.3
+        version: '4.5'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.3.3
-description:
+        version: '4.5'
 email: andrew@ankane.org
 executables: []
 extensions:
@@ -74,7 +72,6 @@ homepage: https://github.com/ankane/or-tools-ruby
 licenses:
 - Apache-2.0
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -89,8 +86,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Operations research tools for Ruby
 test_files: []