or-tools 0.17.1 → 0.18.1

data/ext/or-tools/ext.cpp

@@ -16,7 +16,7 @@ void init_routing(Rice::Module& m);
 
 extern "C"
 void Init_ext() {
-  auto m = Rice::define_module("ORTools");
+  Rice::Module m = Rice::define_module("ORTools");
 
   m.define_singleton_function("lib_version", &operations_research::OrToolsVersionString);
 

data/ext/or-tools/linear.cpp

@@ -8,8 +8,8 @@
 
 using operations_research::MPConstraint;
 using operations_research::MPObjective;
-using operations_research::MPSolverParameters;
 using operations_research::MPSolver;
+using operations_research::MPSolverParameters;
 using operations_research::MPVariable;
 
 using Rice::Array;
@@ -34,13 +34,13 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     static MPSolver::OptimizationProblemType convert(VALUE x) {
-      auto s = Symbol(x).str();
+      std::string s = Symbol(x).str();
       if (s == "glop") {
         return MPSolver::OptimizationProblemType::GLOP_LINEAR_PROGRAMMING;
       } else if (s == "cbc") {
         return MPSolver::OptimizationProblemType::CBC_MIXED_INTEGER_PROGRAMMING;
       } else {
-        throw std::runtime_error("Unknown optimization problem type: " + s);
+        throw std::runtime_error{"Unknown optimization problem type: " + s};
       }
     }
 
@@ -175,7 +175,7 @@ void init_linear(Rice::Module& m) {
       [](const std::string& name, MPSolver::OptimizationProblemType problem_type) {
         MPSolver* solver = new MPSolver(name, problem_type);
         if (!solver) {
-          throw std::runtime_error("Unrecognized solver type");
+          throw std::runtime_error{"Unrecognized solver type"};
         }
         return solver;
       }, Rice::Return().takeOwnership())
@@ -184,7 +184,7 @@ void init_linear(Rice::Module& m) {
       [](const std::string& solver_id) {
         MPSolver* solver = MPSolver::CreateSolver(solver_id);
         if (!solver) {
-          throw std::runtime_error("Unrecognized solver type");
+          throw std::runtime_error{"Unrecognized solver type"};
         }
         return solver;
       }, Rice::Return().takeOwnership())
@@ -239,7 +239,7 @@ void init_linear(Rice::Module& m) {
         } else if (status == MPSolver::ResultStatus::NOT_SOLVED) {
           return Symbol("not_solved");
         } else {
-          throw std::runtime_error("Unknown status");
+          throw std::runtime_error{"Unknown status"};
         }
       })
     .define_method(
@@ -247,7 +247,7 @@ void init_linear(Rice::Module& m) {
       [](MPSolver& self, bool obfuscate) {
         std::string model_str;
         if (!self.ExportModelAsLpFormat(obfuscate, &model_str)) {
-          throw std::runtime_error("Export failed");
+          throw std::runtime_error{"Export failed"};
         }
         return model_str;
       })
@@ -256,7 +256,7 @@ void init_linear(Rice::Module& m) {
       [](MPSolver& self, bool fixed_format, bool obfuscate) {
         std::string model_str;
         if (!self.ExportModelAsMpsFormat(fixed_format, obfuscate, &model_str)) {
-          throw std::runtime_error("Export failed");
+          throw std::runtime_error{"Export failed"};
         }
         return model_str;
       });

data/ext/or-tools/math_opt.cpp

@@ -32,7 +32,7 @@ namespace Rice::detail {
     double is_convertible(VALUE value) { return Convertible::Exact; }
 
     static SolverType convert(VALUE x) {
-      auto s = Symbol(x).str();
+      std::string s = Symbol(x).str();
       if (s == "gscip") {
         return SolverType::kGscip;
       } else if (s == "gurobi") {
@@ -54,7 +54,7 @@ namespace Rice::detail {
       } else if (s == "santorini") {
         return SolverType::kSantorini;
       } else {
-        throw std::runtime_error("Unknown solver type: " + s);
+        throw std::runtime_error{"Unknown solver type: " + s};
       }
     }
 
@@ -71,11 +71,11 @@ void init_math_opt(Rice::Module& m) {
     .define_method(
       "name",
       [](Variable& self) {
-        return std::string(self.name());
+        return std::string{self.name()};
       })
     .define_method(
       "_eql?",
-      [](Variable& self, Variable &other) {
+      [](Variable& self, Variable& other) {
         return static_cast<bool>(self == other);
       });
 
@@ -106,7 +106,7 @@ void init_math_opt(Rice::Module& m) {
         } else if (reason == TerminationReason::kOtherError) {
           return Rice::Symbol("other");
         } else {
-          throw std::runtime_error("Unknown termination reason");
+          throw std::runtime_error{"Unknown termination reason"};
         }
       });
 
@@ -143,18 +143,18 @@ void init_math_opt(Rice::Module& m) {
       })
     .define_method(
       "_set_upper_bound",
-      [](Model& self, LinearConstraint constraint, double upper_bound) {
+      [](Model& self, const LinearConstraint& constraint, double upper_bound) {
         self.set_upper_bound(constraint, upper_bound);
       })
     .define_method(
       "_set_lower_bound",
-      [](Model& self, LinearConstraint constraint, double upper_bound) {
+      [](Model& self, const 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) {
+      [](Model& self, const Variable& variable, double value) {
         self.set_objective_coefficient(variable, value);
       })
     .define_method("_clear_objective", &Model::clear_objective)

data/ext/or-tools/network_flows.cpp

@@ -36,7 +36,7 @@ void init_network_flows(Rice::Module& m) {
         } else if (status == SimpleMaxFlow::Status::BAD_RESULT) {
           return Symbol("bad_result");
         } else {
-          throw std::runtime_error("Unknown status");
+          throw std::runtime_error{"Unknown status"};
         }
       })
     .define_method(
@@ -98,7 +98,7 @@ void init_network_flows(Rice::Module& m) {
         } else if (status == SimpleMinCostFlow::Status::BAD_COST_RANGE) {
           return Symbol("bad_cost_range");
         } else {
-          throw std::runtime_error("Unknown status");
+          throw std::runtime_error{"Unknown status"};
         }
       });
 }