or-tools 0.6.2 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0e0f455741da72e3a215287df4ef1858893fb31d0b4be40db6ef9ab025e339c
-  data.tar.gz: 9291933eee08f800f48f3d83ca4f2d0fc71efb0a328134ba9667ca2ac8efb185
+  metadata.gz: d3cfb5b8fd7f6a4563b2d50a2357e4bfc72fc5ef69e2c7c1a6ad7e7736a66235
+  data.tar.gz: a1e2307c4a94495f9fe28e85e68171a9a3474a45ed98344250920360adffbd0f
 SHA512:
-  metadata.gz: 61ccc7c5f3a6c3cdf1e3dffb1ee6572d0b8cde09d4684d50353efd6f2efcb93ca4ba940343f994a3bf65992e518331bd62a02ef74ecc52f2427e12350ea7a430
-  data.tar.gz: 589423f5b52c872b453569400ff1fd60bb1fcd3b0035e70aadbb47eedefec9b7f4187a5442893e50608529f836d2009bd77333aae3f64ce1b9d700df6fe020e7
+  metadata.gz: 8b62fd4b68b1a3b119d8da2987d263ad2fb0c4ca4d1062ef274f3dea440db62414af6188b769180a740a22898d26657569e71fefd0af9e754442061bcf481a1a
+  data.tar.gz: c4fbe636cd22654c867f25c954d1652540b54239a9427a7795033027a60ca7538b864e74c0134296040f57bf945750dbc80384965e7d449f9a5fb1474163ce9d

data/CHANGELOG.md

@@ -1,3 +1,22 @@
+## 0.7.1 (2022-05-27)
+
+- Added support for time limit for `Solver`
+- Added `enable_output` and `suppress_output` to `Solver`
+- Improved `new` method for `Solver`
+- Fixed error with offset with `Solver`
+- Fixed segfault with `CpSolver`
+
+## 0.7.0 (2022-03-23)
+
+- Updated OR-Tools to 9.3
+- Removed `add_lin_min_equality` (use `add_min_equality` instead)
+- Removed `add_lin_max_equality` (use `add_max_equality` instead)
+- Dropped support for Debian 10
+
+## 0.6.3 (2022-03-13)
+
+- Reduced gem size
+
 ## 0.6.2 (2022-02-09)
 
 - Fixed segfaults with `Solver`

data/README.md

@@ -14,13 +14,73 @@ gem "or-tools"
 
 Installation can take a few minutes as OR-Tools downloads and builds. For Mac ARM, also follow [these instructions](#additional-instructions).
 
-## Higher Level Interfaces
+## Guides
+
+Higher Level Interfaces
 
 - [Scheduling](#scheduling)
 - [Seating](#seating)
 - [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp)
 - [Sudoku](#sudoku)
 
+Linear Optimization
+
+- [Solving an LP Problem](#solving-an-lp-problem)
+
+Integer Optimization
+
+- [Solving a MIP Problem](#solving-a-mip-problem)
+
+Constraint Optimization
+
+- [CP-SAT Solver](#cp-sat-solver)
+- [Solving a CP Problem](#solving-a-cp-problem)
+- [Cryptarithmetic](#cryptarithmetic)
+- [The N-queens Problem](#the-n-queens-problem)
+- [Setting Solver Limits](#setting-solver-limits)
+
+Assignment
+
+- [Solving an Assignment Problem](#solving-an-assignment-problem)
+- [Assignment with Teams of Workers](#assignment-with-teams-of-workers)
+- [Linear Sum Assignment Solver](#linear-sum-assignment-solver)
+
+Routing
+
+- [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp-1)
+- [Vehicle Routing Problem (VRP)](#vehicle-routing-problem-vrp)
+- [Capacity Constraints](#capacity-constraints)
+- [Pickups and Deliveries](#pickups-and-deliveries)
+- [Time Window Constraints](#time-window-constraints)
+- [Resource Constraints](#resource-constraints)
+- [Penalties and Dropping Visits](#penalties-and-dropping-visits)
+- [Routing Options](#routing-options)
+
+Bin Packing
+
+- [The Knapsack Problem](#the-knapsack-problem)
+- [Multiple Knapsacks](#multiple-knapsacks)
+- [Bin Packing Problem](#bin-packing-problem)
+
+Network Flows
+
+- [Maximum Flows](#maximum-flows)
+- [Minimum Cost Flows](#minimum-cost-flows)
+- [Assignment as a Min Cost Flow Problem](#assignment-as-a-min-cost-flow-problem)
+
+Scheduling
+
+- [Employee Scheduling](#employee-scheduling)
+- [The Job Shop Problem](#the-job-shop-problem)
+
+Other Examples
+
+- [Sudoku](#sudoku-1)
+- [Wedding Seating Chart](#wedding-seating-chart)
+- [Set Partitioning](#set-partitioning)
+
+## Higher Level Interfaces
+
 ### Scheduling
 
 Specify people and their availabililty
@@ -251,138 +311,69 @@ sudoku = ORTools::Sudoku.new(grid, x: true, anti_knight: true, magic_square: tru
 sudoku.solution
 ```
 
-## Guides
+## Linear Optimization
 
-Linear Optimization
-
-- [The Glop Linear Solver](#the-glop-linear-solver)
+### Solving an LP Problem
 
-Integer Optimization
-
-- [Mixed-Integer Programming](#mixed-integer-programming)
-
-Constraint Optimization
-
-- [CP-SAT Solver](#cp-sat-solver)
-- [Solving an Optimization Problem](#solving-an-optimization-problem)
-- [Cryptarithmetic](#cryptarithmetic)
-- [The N-queens Problem](#the-n-queens-problem)
-- [Setting Solver Limits](#setting-solver-limits)
-
-Assignment
-
-- [Assignment](#assignment)
-- [Assignment with Teams](#assignment-with-teams)
-
-Routing
-
-- [Traveling Salesperson Problem (TSP)](#traveling-salesperson-problem-tsp-1)
-- [Vehicle Routing Problem (VRP)](#vehicle-routing-problem-vrp)
-- [Capacity Constraints](#capacity-constraints)
-- [Pickups and Deliveries](#pickups-and-deliveries)
-- [Time Window Constraints](#time-window-constraints)
-- [Resource Constraints](#resource-constraints)
-- [Penalties and Dropping Visits](#penalties-and-dropping-visits)
-- [Routing Options](#routing-options)
-
-Bin Packing
-
-- [The Knapsack Problem](#the-knapsack-problem)
-- [Multiple Knapsacks](#multiple-knapsacks)
-- [Bin Packing Problem](#bin-packing-problem)
-
-Network Flows
-
-- [Maximum Flows](#maximum-flows)
-- [Minimum Cost Flows](#minimum-cost-flows)
-- [Assignment as a Min Cost Flow Problem](#assignment-as-a-min-cost-flow-problem)
-
-Scheduling
-
-- [Employee Scheduling](#employee-scheduling)
-- [The Job Shop Problem](#the-job-shop-problem)
-
-Other Examples
-
-- [Sudoku](#sudoku-1)
-- [Wedding Seating Chart](#wedding-seating-chart)
-- [Set Partitioning](#set-partitioning)
-
-### The Glop Linear Solver
-
-[Guide](https://developers.google.com/optimization/lp/glop)
+[Guide](https://developers.google.com/optimization/lp/lp_example)
 
 ```ruby
 # declare the solver
-solver = ORTools::Solver.new("LinearProgrammingExample", :glop)
+solver = ORTools::Solver.new("GLOP")
 
 # create the variables
 x = solver.num_var(0, solver.infinity, "x")
 y = solver.num_var(0, solver.infinity, "y")
+puts "Number of variables = #{solver.num_variables}"
 
 # define the constraints
-constraint0 = solver.constraint(-solver.infinity, 14)
-constraint0.set_coefficient(x, 1)
-constraint0.set_coefficient(y, 2)
-
-constraint1 = solver.constraint(0, solver.infinity)
-constraint1.set_coefficient(x, 3)
-constraint1.set_coefficient(y, -1)
-
-constraint2 = solver.constraint(-solver.infinity, 2)
-constraint2.set_coefficient(x, 1)
-constraint2.set_coefficient(y, -1)
+solver.add(x + 2 * y <= 14)
+solver.add(3 * x - y >= 0)
+solver.add(x - y <= 2)
+puts "Number of constraints = #{solver.num_constraints}"
 
 # define the objective function
-objective = solver.objective
-objective.set_coefficient(x, 3)
-objective.set_coefficient(y, 4)
-objective.set_maximization
+solver.maximize(3 * x + 4 * y)
 
 # invoke the solver
-solver.solve
+status = solver.solve
 
 # display the solution
-opt_solution = 3 * x.solution_value + 4 * y.solution_value
-puts "Number of variables = #{solver.num_variables}"
-puts "Number of constraints = #{solver.num_constraints}"
-puts "Solution:"
-puts "x = #{x.solution_value}"
-puts "y = #{y.solution_value}"
-puts "Optimal objective value = #{opt_solution}"
+if status == :optimal
+  puts "Solution:"
+  puts "Objective value = #{solver.objective.value}"
+  puts "x = #{x.solution_value}"
+  puts "y = #{y.solution_value}"
+else
+  puts "The problem does not have an optimal solution."
+end
 ```
 
-### Mixed-Integer Programming
+## Integer Optimization
 
-[Guide](https://developers.google.com/optimization/mip/integer_opt)
+### Solving a MIP Problem
+
+[Guide](https://developers.google.com/optimization/mip/mip_example)
 
 ```ruby
 # declare the MIP solver
-solver = ORTools::Solver.new("simple_mip_program", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # define the variables
 infinity = solver.infinity
-x = solver.int_var(0.0, infinity, "x")
-y = solver.int_var(0.0, infinity, "y")
+x = solver.int_var(0, infinity, "x")
+y = solver.int_var(0, infinity, "y")
 
 puts "Number of variables = #{solver.num_variables}"
 
 # define the constraints
-c0 = solver.constraint(-infinity, 17.5)
-c0.set_coefficient(x, 1)
-c0.set_coefficient(y, 7)
-
-c1 = solver.constraint(-infinity, 3.5)
-c1.set_coefficient(x, 1);
-c1.set_coefficient(y, 0);
+solver.add(x + 7 * y <= 17.5)
+solver.add(x <= 3.5)
 
 puts "Number of constraints = #{solver.num_constraints}"
 
 # define the objective
-objective = solver.objective
-objective.set_coefficient(x, 1)
-objective.set_coefficient(y, 10)
-objective.set_maximization
+solver.maximize(x + 10 * y)
 
 # call the solver
 status = solver.solve
@@ -398,6 +389,8 @@ else
 end
 ```
 
+## Constraint Optimization
+
 ### CP-SAT Solver
 
 [Guide](https://developers.google.com/optimization/cp/cp_solver)
@@ -420,16 +413,18 @@ solver = ORTools::CpSolver.new
 status = solver.solve(model)
 
 # display the first solution
-if status == :optimal
+if status == :optimal || status == :feasible
   puts "x = #{solver.value(x)}"
   puts "y = #{solver.value(y)}"
   puts "z = #{solver.value(z)}"
+else
+  puts "No solution found."
 end
 ```
 
-### Solving an Optimization Problem
+### Solving a CP Problem
 
-[Guide](https://developers.google.com/optimization/cp/integer_opt_cp)
+[Guide](https://developers.google.com/optimization/cp/cp_example)
 
 ```ruby
 # declare the model
@@ -453,12 +448,14 @@ model.maximize(x*2 + y*2 + z*3)
 solver = ORTools::CpSolver.new
 status = solver.solve(model)
 
-if status == :optimal
+# display the solution
+if status == :optimal || status == :feasible
   puts "Maximum of objective function: #{solver.objective_value}"
-  puts
-  puts "x value: #{solver.value(x)}"
-  puts "y value: #{solver.value(y)}"
-  puts "z value: #{solver.value(z)}"
+  puts "x = #{solver.value(x)}"
+  puts "y = #{solver.value(y)}"
+  puts "z = #{solver.value(z)}"
+else
+  puts "No solution found."
 end
 ```
 
@@ -613,120 +610,190 @@ if status == :optimal
 end
 ```
 
-### Assignment
+## Assignment
+
+### Solving an Assignment Problem
 
 [Guide](https://developers.google.com/optimization/assignment/assignment_example)
 
 ```ruby
 # create the data
-cost = [[ 90,  76, 75,  70],
-        [ 35,  85, 55,  65],
-        [125,  95, 90, 105],
-        [ 45, 110, 95, 115]]
-
-rows = cost.length
-cols = cost[0].length
+costs = [
+  [90, 80, 75, 70],
+  [35, 85, 55, 65],
+  [125, 95, 90, 95],
+  [45, 110, 95, 115],
+  [50, 100, 90, 100]
+]
+num_workers = costs.length
+num_tasks = costs[0].length
 
 # create the solver
-assignment = ORTools::LinearSumAssignment.new
+solver = ORTools::Solver.new("CBC")
 
-# add the costs to the solver
-rows.times do |worker|
-  cols.times do |task|
-    if cost[worker][task]
-      assignment.add_arc_with_cost(worker, task, cost[worker][task])
-    end
+# create the variables
+x = {}
+num_workers.times do |i|
+  num_tasks.times do |j|
+    x[[i, j]] = solver.int_var(0, 1, "")
   end
 end
 
+# create the constraints
+# each worker is assigned to at most 1 task
+num_workers.times do |i|
+  solver.add(num_tasks.times.sum { |j| x[[i, j]] } <= 1)
+end
+
+# each task is assigned to exactly one worker
+num_tasks.times do |j|
+  solver.add(num_workers.times.sum { |i| x[[i, j]] } == 1)
+end
+
+# create the objective function
+objective_terms = []
+num_workers.times do |i|
+  num_tasks.times do |j|
+    objective_terms << (costs[i][j] * x[[i, j]])
+  end
+end
+solver.minimize(objective_terms.sum)
+
 # invoke the solver
-solve_status = assignment.solve
-if solve_status == :optimal
-  puts "Total cost = #{assignment.optimal_cost}"
-  puts
-  assignment.num_nodes.times do |i|
-    puts "Worker %d assigned to task %d.  Cost = %d" % [
-      i,
-      assignment.right_mate(i),
-      assignment.assignment_cost(i)
-    ]
+status = solver.solve
+
+# print the solution
+if status == :optimal || status == :feasible
+  puts "Total cost = #{solver.objective.value}"
+  num_workers.times do |i|
+    num_tasks.times do |j|
+      # test if x[i,j] is 1 (with tolerance for floating point arithmetic)
+      if x[[i, j]].solution_value > 0.5
+        puts "Worker #{i} assigned to task #{j}. Cost = #{costs[i][j]}"
+      end
+    end
   end
-elsif solve_status == :infeasible
-  puts "No assignment is possible."
-elsif solve_status == :possible_overflow
-  puts "Some input costs are too large and may cause an integer overflow."
+else
+  puts "No solution found."
 end
 ```
 
-### Assignment with Teams
+### Assignment with Teams of Workers
 
-[Guide](https://developers.google.com/optimization/assignment/assignment_teams)
+[Guide](https://developers.google.com/optimization/assignment/assignment_teams#mip)
 
 ```ruby
-# create the solver
-solver = ORTools::Solver.new("SolveAssignmentProblemMIP", :cbc)
-
 # create the data
-cost = [[90, 76, 75, 70],
-        [35, 85, 55, 65],
-        [125, 95, 90, 105],
-        [45, 110, 95, 115],
-        [60, 105, 80, 75],
-        [45, 65, 110, 95]]
+costs = [
+  [90, 76, 75, 70],
+  [35, 85, 55, 65],
+  [125, 95, 90, 105],
+  [45, 110, 95, 115],
+  [60, 105, 80, 75],
+  [45, 65, 110, 95]
+]
+num_workers = costs.length
+num_tasks = costs[1].length
 
 team1 = [0, 2, 4]
 team2 = [1, 3, 5]
 team_max = 2
 
+# create the solver
+solver = ORTools::Solver.new("CBC")
+
 # create the variables
-num_workers = cost.length
-num_tasks = cost[1].length
 x = {}
-
 num_workers.times do |i|
   num_tasks.times do |j|
     x[[i, j]] = solver.bool_var("x[#{i},#{j}]")
   end
 end
 
-# create the objective function
-solver.minimize(solver.sum(
-  num_workers.times.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] * cost[i][j] } }
-))
-
-# create the constraints
+# add the constraints
+# each worker is assigned at most 1 task
 num_workers.times do |i|
-  solver.add(solver.sum(num_tasks.times.map { |j| x[[i, j]] }) <= 1)
+  solver.add(num_tasks.times.sum { |j| x[[i, j]] } <= 1)
 end
 
+# each task is assigned to exactly one worker
 num_tasks.times do |j|
-  solver.add(solver.sum(num_workers.times.map { |i| x[[i, j]] }) == 1)
+  solver.add(num_workers.times.sum { |i| x[[i, j]] } == 1)
 end
 
-solver.add(solver.sum(team1.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }) <= team_max)
-solver.add(solver.sum(team2.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }) <= team_max)
+# each team takes at most two tasks
+solver.add(team1.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }.sum <= team_max)
+solver.add(team2.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] } }.sum <= team_max)
+
+# create the objective
+solver.minimize(
+  num_workers.times.flat_map { |i| num_tasks.times.map { |j| x[[i, j]] * costs[i][j] } }.sum
+)
 
 # invoke the solver
-sol = solver.solve
+status = solver.solve
 
-puts "Total cost = #{solver.objective.value}"
-puts
-num_workers.times do |i|
-  num_tasks.times do |j|
-    if x[[i, j]].solution_value > 0
-      puts "Worker %d assigned to task %d.  Cost = %d" % [
-        i,
-        j,
-        cost[i][j]
-      ]
+# display the results
+if status == :optimal || status == :feasible
+  puts "Total cost = #{solver.objective.value}"
+  num_workers.times do |worker|
+    num_tasks.times do |task|
+      if x[[worker, task]].solution_value > 0.5
+        puts "Worker #{worker} assigned to task #{task}. Cost = #{costs[worker][task]}"
+      end
     end
   end
+else
+  puts "No solution found."
 end
+```
 
-puts
-puts "Time = #{solver.wall_time} milliseconds"
+### Linear Sum Assignment Solver
+
+[Guide](https://developers.google.com/optimization/assignment/linear_assignment)
+
+```ruby
+# create the data
+costs = [
+  [90, 76, 75, 70],
+  [35, 85, 55, 65],
+  [125, 95, 90, 105],
+  [45, 110, 95, 115],
+]
+num_workers = costs.length
+num_tasks = costs[0].length
+
+# create the solver
+assignment = ORTools::LinearSumAssignment.new
+
+# add the constraints
+num_workers.times do |worker|
+  num_tasks.times do |task|
+    if costs[worker][task]
+      assignment.add_arc_with_cost(worker, task, costs[worker][task])
+    end
+  end
+end
+
+# invoke the solver
+status = assignment.solve
+
+# display the results
+case status
+when :optimal
+  puts "Total cost = #{assignment.optimal_cost}"
+  assignment.num_nodes.times do |i|
+    puts "Worker #{i} assigned to task #{assignment.right_mate(i)}. Cost = #{assignment.assignment_cost(i)}"
+  end
+when :infeasible
+  puts "No assignment is possible."
+when :possible_overflow
+  puts "Some input costs are too large and may cause an integer overflow."
+end
 ```
 
+## Routing
+
 ### Traveling Salesperson Problem (TSP)
 
 [Guide](https://developers.google.com/optimization/routing/tsp.html)
@@ -1376,6 +1443,8 @@ routing.solve(
 )
 ```
 
+## Bin Packing
+
 ### The Knapsack Problem
 
 [Guide](https://developers.google.com/optimization/bin/knapsack)
@@ -1425,53 +1494,40 @@ puts "Packed weights: #{packed_weights}"
 ```ruby
 # create the data
 data = {}
-weights = [48, 30, 42, 36, 36, 48, 42, 42, 36, 24, 30, 30, 42, 36, 36]
-values = [10, 30, 25, 50, 35, 30, 15, 40, 30, 35, 45, 10, 20, 30, 25]
-data[:weights] = weights
-data[:values] = values
-data[:items] = (0...weights.length).to_a
-data[:num_items] = weights.length
-num_bins = 5
-data[:bins] = (0...num_bins).to_a
+data[:weights] = [48, 30, 42, 36, 36, 48, 42, 42, 36, 24, 30, 30, 42, 36, 36]
+data[:values] = [10, 30, 25, 50, 35, 30, 15, 40, 30, 35, 45, 10, 20, 30, 25]
+data[:num_items] = data[:weights].length
+data[:all_items] = data[:num_items].times.to_a
 data[:bin_capacities] = [100, 100, 100, 100, 100]
+data[:num_bins] = data[:bin_capacities].length
+data[:all_bins] = data[:num_bins].times.to_a
 
 # declare the solver
-solver = ORTools::Solver.new("simple_mip_program", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # create the variables
-# x[i, j] = 1 if item i is packed in bin j
 x = {}
-data[:items].each do |i|
-  data[:bins].each do |j|
-    x[[i, j]] = solver.int_var(0, 1, "x_%i_%i" % [i, j])
+data[:all_items].each do |i|
+  data[:all_bins].each do |b|
+    x[[i, b]] = solver.bool_var("x_#{i}_#{b}")
   end
 end
 
-# define the constraints
-# each item can be in at most one bin
-data[:items].each do |i|
-  sum = ORTools::LinearExpr.new
-  data[:bins].each do |j|
-    sum += x[[i, j]]
-  end
-  solver.add(sum <= 1.0)
+# each item is assigned to at most one bin
+data[:all_items].each do |i|
+  solver.add(data[:all_bins].sum { |b| x[[i, b]] } <= 1)
 end
 
 # the amount packed in each bin cannot exceed its capacity
-data[:bins].each do |j|
-  weight = ORTools::LinearExpr.new
-  data[:items].each do |i|
-    weight += x[[i, j]] * data[:weights][i]
-  end
-  solver.add(weight <= data[:bin_capacities][j])
+data[:all_bins].each do |b|
+  solver.add(data[:all_items].sum { |i| x[[i, b]] * data[:weights][i] } <= data[:bin_capacities][b])
 end
 
-# define the objective
+# maximize total value of packed items
 objective = solver.objective
-
-data[:items].each do |i|
-  data[:bins].each do |j|
-    objective.set_coefficient(x[[i, j]], data[:values][i])
+data[:all_items].each do |i|
+  data[:all_bins].each do |b|
+    objective.set_coefficient(x[[i, b]], data[:values][i])
   end
 end
 objective.set_maximization
@@ -1482,12 +1538,12 @@ status = solver.solve
 if status == :optimal
   puts "Total packed value: #{objective.value}"
   total_weight = 0
-  data[:bins].each do |j|
+  data[:all_bins].each do |b|
     bin_weight = 0
     bin_value = 0
-    puts "Bin  #{j}\n\n"
-    data[:items].each do |i|
-      if x[[i, j]].solution_value > 0
+    puts "Bin #{b}\n\n"
+    data[:all_items].each do |i|
+      if x[[i, b]].solution_value > 0
         puts "Item #{i} - weight: #{data[:weights][i]}  value: #{data[:values][i]}"
         bin_weight += data[:weights][i]
         bin_value += data[:values][i]
@@ -1518,7 +1574,7 @@ data[:bins] = data[:items]
 data[:bin_capacity] = 100
 
 # create the mip solver with the CBC backend
-solver = ORTools::Solver.new("simple_mip_program", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # variables
 # x[i, j] = 1 if item i is packed in bin j
@@ -1538,17 +1594,17 @@ end
 # constraints
 # each item must be in exactly one bin
 data[:items].each do |i|
-  solver.add(solver.sum(data[:bins].map { |j| x[[i, j]] }) == 1)
+  solver.add(data[:bins].sum { |j| x[[i, j]] } == 1)
 end
 
 # the amount packed in each bin cannot exceed its capacity
 data[:bins].each do |j|
-  sum = solver.sum(data[:items].map { |i| x[[i, j]] * data[:weights][i] })
+  sum = data[:items].sum { |i| x[[i, j]] * data[:weights][i] }
   solver.add(sum <= y[j] * data[:bin_capacity])
 end
 
 # objective: minimize the number of bins used
-solver.minimize(solver.sum(data[:bins].map { |j| y[j] }))
+solver.minimize(data[:bins].sum { |j| y[j] })
 
 # call the solver and print the solution
 if status == :optimal
@@ -1580,6 +1636,8 @@ else
 end
 ```
 
+## Network Flows
+
 ### Maximum Flows
 
 [Guide](https://developers.google.com/optimization/flow/maxflow)
@@ -1664,7 +1722,7 @@ end
 
 ### Assignment as a Min Cost Flow Problem
 
-[Guide](https://developers.google.com/optimization/assignment/assignment_min_cost_flow)
+[Guide](https://developers.google.com/optimization/flow/assignment_min_cost_flow)
 
 ```ruby
 # create the solver
@@ -1711,6 +1769,8 @@ else
 end
 ```
 
+## Scheduling
+
 ### Employee Scheduling
 
 [Guide](https://developers.google.com/optimization/scheduling/employee_scheduling)
@@ -1915,6 +1975,8 @@ puts "Optimal Schedule Length: %i" % solver.objective_value
 puts output
 ```
 
+## Other Examples
+
 ### Sudoku
 
 [Example](https://github.com/google/or-tools/blob/stable/examples/python/sudoku_sat.py)
@@ -2172,7 +2234,7 @@ possible_tables = []
   possible_tables += guests.combination(i).to_a
 end
 
-solver = ORTools::Solver.new("Wedding Seating Model", :cbc)
+solver = ORTools::Solver.new("CBC")
 
 # create a binary variable to state that a table setting is used
 x = {}
@@ -2180,15 +2242,15 @@ possible_tables.each do |table|
   x[table] = solver.int_var(0, 1, "table #{table.join(", ")}")
 end
 
-solver.minimize(solver.sum(possible_tables.map { |table| x[table] * happiness(table) }))
+solver.minimize(possible_tables.sum { |table| x[table] * happiness(table) })
 
 # specify the maximum number of tables
-solver.add(solver.sum(x.values) <= max_tables)
+solver.add(x.values.sum <= max_tables)
 
 # a guest must seated at one and only one table
 guests.each do |guest|
   tables_with_guest = possible_tables.select { |table| table.include?(guest) }
-  solver.add(solver.sum(tables_with_guest.map { |table| x[table] }) == 1)
+  solver.add(tables_with_guest.sum { |table| x[table] } == 1)
 end
 
 status = solver.solve

data/ext/or-tools/constraint.cpp

@@ -57,11 +57,11 @@ namespace Rice::detail
           auto coeff = From_Ruby<int64_t>().convert(cvar[1].value());
 
           if (var.is_a(rb_cBoolVar)) {
-            expr.AddTerm(From_Ruby<BoolVar>().convert(var.value()), coeff);
+            expr += From_Ruby<BoolVar>().convert(var.value()) * coeff;
           } else if (var.is_a(rb_cInteger)) {
-            expr.AddConstant(From_Ruby<int64_t>().convert(var.value()) * coeff);
+            expr += From_Ruby<int64_t>().convert(var.value()) * coeff;
           } else {
-            expr.AddTerm(From_Ruby<IntVar>().convert(var.value()), coeff);
+            expr += From_Ruby<IntVar>().convert(var.value()) * coeff;
           }
         }
       } else {
@@ -253,42 +253,32 @@ void init_constraint(Rice::Module& m) {
       })
     .define_method(
       "add_min_equality",
-      [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
+      [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> vars) {
         return self.AddMinEquality(target, vars);
       })
-    .define_method(
-      "add_lin_min_equality",
-      [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> exprs) {
-        return self.AddLinMinEquality(target, exprs);
-      })
     .define_method(
       "add_max_equality",
-      [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
+      [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> vars) {
         return self.AddMaxEquality(target, vars);
       })
-    .define_method(
-      "add_lin_max_equality",
-      [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> exprs) {
-        return self.AddLinMaxEquality(target, exprs);
-      })
     .define_method(
       "add_division_equality",
-      [](CpModelBuilder& self, IntVar target, IntVar numerator, IntVar denominator) {
+      [](CpModelBuilder& self, LinearExpr target, LinearExpr numerator, LinearExpr denominator) {
         return self.AddDivisionEquality(target, numerator, denominator);
       })
     .define_method(
       "add_abs_equality",
-      [](CpModelBuilder& self, IntVar target, IntVar var) {
+      [](CpModelBuilder& self, LinearExpr target, LinearExpr var) {
         return self.AddAbsEquality(target, var);
       })
     .define_method(
       "add_modulo_equality",
-      [](CpModelBuilder& self, IntVar target, IntVar var, IntVar mod) {
+      [](CpModelBuilder& self, LinearExpr target, LinearExpr var, LinearExpr mod) {
         return self.AddModuloEquality(target, var, mod);
       })
     .define_method(
       "add_multiplication_equality",
-      [](CpModelBuilder& self, IntVar target, std::vector<IntVar> vars) {
+      [](CpModelBuilder& self, LinearExpr target, std::vector<LinearExpr> vars) {
         return self.AddMultiplicationEquality(target, vars);
       })
     .define_method(

data/ext/or-tools/ext.cpp

@@ -1,7 +1,11 @@
 #include <ortools/base/version.h>
+#include <ortools/init/init.h>
 
 #include "ext.h"
 
+using operations_research::CppBridge;
+using operations_research::CppFlags;
+
 void init_assignment(Rice::Module& m);
 void init_bin_packing(Rice::Module& m);
 void init_constraint(Rice::Module& m);
@@ -14,6 +18,7 @@ void Init_ext()
 {
   auto m = Rice::define_module("ORTools");
 
+  // TODO use operations_research::OrToolsVersionString() in 0.8.0
   m.define_singleton_function(
     "lib_version",
     []() {
@@ -27,4 +32,11 @@ void Init_ext()
   init_linear(m);
   init_network_flows(m);
   init_routing(m);
+
+  // fix logging warning
+  CppBridge::InitLogging("");
+  CppFlags flags = CppFlags();
+  flags.logtostderr = true;
+  flags.log_prefix = false;
+  CppBridge::SetFlags(flags);
 }

data/ext/or-tools/extconf.rb

@@ -25,12 +25,7 @@ end
 
 $INCFLAGS << " -I#{inc}"
 
-$LDFLAGS << " -Wl,-rpath,#{rpath}"
-$LDFLAGS << " -L#{lib}"
+$LDFLAGS.prepend("-Wl,-rpath,#{rpath} -L#{lib} ")
 raise "OR-Tools not found" unless have_library("ortools")
 
-Dir["#{lib}/libabsl_*.a"].each do |lib|
-  $LDFLAGS << " #{lib}"
-end
-
 create_makefile("or_tools/ext")

data/ext/or-tools/linear.cpp

@@ -47,7 +47,7 @@ namespace Rice::detail
 void init_linear(Rice::Module& m) {
   Rice::define_class_under<LinearRange>(m, "LinearRange");
 
-  // TODO remove in 0.7.0
+  // TODO remove in 0.8.0
   auto rb_cLinearExpr = Rice::define_class_under<LinearExpr>(m, "LinearExpr");
   rb_cLinearExpr.define_constructor(Rice::Constructor<LinearExpr>());
 
@@ -60,12 +60,29 @@ void init_linear(Rice::Module& m) {
 
   Rice::define_class_under<MPObjective>(m, "MPObjective")
     .define_method("value", &MPObjective::Value)
+    .define_method("clear", &MPObjective::Clear)
     .define_method("set_coefficient", &MPObjective::SetCoefficient)
+    .define_method("set_offset", &MPObjective::SetOffset)
     .define_method("set_maximization", &MPObjective::SetMaximization)
     .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(
+      "_create",
+      [](const std::string& solver_id) {
+        std::unique_ptr<MPSolver> solver(MPSolver::CreateSolver(solver_id));
+        if (!solver) {
+          throw std::runtime_error("Unrecognized solver type");
+        }
+        return solver;
+      })
+    .define_method(
+      "time_limit=",
+      [](MPSolver& self, double time_limit) {
+        // use milliseconds to match Python
+        self.SetTimeLimit(absl::Milliseconds(time_limit));
+      })
     .define_method(
       "infinity",
       [](MPSolver& self) {
@@ -81,6 +98,8 @@ void init_linear(Rice::Module& m) {
     .define_method("num_variables", &MPSolver::NumVariables)
     .define_method("num_constraints", &MPSolver::NumConstraints)
     .define_method("wall_time", &MPSolver::wall_time)
+    .define_method("enable_output", &MPSolver::EnableOutput)
+    .define_method("suppress_output", &MPSolver::SuppressOutput)
     .define_method("iterations", &MPSolver::iterations)
     .define_method("nodes", &MPSolver::nodes)
     .define_method("objective", &MPSolver::MutableObjective)

data/ext/or-tools/vendor.rb

@@ -4,7 +4,7 @@ require "fileutils"
 require "net/http"
 require "tmpdir"
 
-version = "9.2.9972"
+version = "9.3.10497"
 
 if RbConfig::CONFIG["host_os"] =~ /darwin/i
   if RbConfig::CONFIG["host_cpu"] =~ /arm|aarch64/i
@@ -17,8 +17,8 @@ if RbConfig::CONFIG["host_os"] =~ /darwin/i
 
     MSG
   else
-    filename = "or-tools_MacOsX-12.0.1_v#{version}.tar.gz"
-    checksum = "796791a8ef84507d62e193e647cccb1c7725dae4f1474476e1777fe4a44ee3e0"
+    filename = "or-tools_MacOsX-12.2.1_v#{version}.tar.gz"
+    checksum = "33941702c59983897935eef06d91aca6c89ed9a8f5f4de3a9dfe489e97d7ca8c"
   end
 else
   # try /etc/os-release with fallback to /usr/lib/os-release
@@ -32,23 +32,21 @@ else
   os_version = os_info["VERSION_ID"]
 
   if os == "ubuntu" && os_version == "20.04"
-    filename = "or-tools_amd64_ubuntu-20.04_v#{version}.tar.gz"
-    checksum = "985e3036eaecacfc8a0258ec2ebef429240491577d4e0896d68fc076e65451ec"
+    # TODO remove sub in v9.4
+    filename = "or-tools_amd64_ubuntu-20.04_v#{version.sub(".10497", ".10502")}.tar.gz"
+    checksum = "3d1979967a2c9358b5bc956f2e6b608b00e89e13c71d48d075475ce4138b6d1c"
   elsif os == "ubuntu" && os_version == "18.04"
     filename = "or-tools_amd64_ubuntu-18.04_v#{version}.tar.gz"
-    checksum = "e36406c4fe8c111e1ace0ede9d0787ff0e98f11afd7db9cc074adfd0f55628a6"
+    checksum = "6ba5cc153417267e8f8e15f8b6390b17f22de07bacc61f3740a4172ccd56c274"
   elsif os == "debian" && os_version == "11"
     filename = "or-tools_amd64_debian-11_v#{version}.tar.gz"
-    checksum = "bd49ee916213b2140ab255414d35a28f19dff7caf87632309753d3fc553f85dd"
-  elsif os == "debian" && os_version == "10"
-    filename = "or-tools_amd64_debian-10_v#{version}.tar.gz"
-    checksum = "b152fee584f0c8228fe2ff21b74c789870ff9b7064e42ca26305c6b5653f0064"
+    checksum = "db0636bab909eabf06a7004f7572dca6fa152f3823c1365b0b7428405bf250e6"
   elsif os == "centos" && os_version == "8"
     filename = "or-tools_amd64_centos-8_v#{version}.tar.gz"
-    checksum = "66ed4bb800acf92c672f7e68acdf4ea27bbfdb17bbddc02f8326cd55a97305f6"
+    checksum = "e5649069fd7a3e8228cc18b91e265a90562c5d03a0c962b0346911aada0aedc9"
   elsif os == "centos" && os_version == "7"
     filename = "or-tools_amd64_centos-7_v#{version}.tar.gz"
-    checksum = "4a5c1b1639a2828cd7e1ba82a574ef37876557b59e8aab8b81811bb750d53035"
+    checksum = "3bffdec8c09fc1345dcbd6a553437e2894014093fafb53e50adc7d4d776bb08b"
   else
     platform =
       if Gem.win_platform?
@@ -121,12 +119,37 @@ end
 download_checksum = Digest::SHA256.file(download_path).hexdigest
 raise "Bad checksum: #{download_checksum}" if download_checksum != checksum
 
-# extract - can't use Gem::Package#extract_tar_gz from RubyGems
-# since it limits filenames to 100 characters (doesn't support UStar format)
 path = File.expand_path("../../tmp/or-tools", __dir__)
 FileUtils.mkdir_p(path)
-tar_args = Gem.win_platform? ? ["--force-local"] : []
-system "tar", "zxf", download_path, "-C", path, "--strip-components=1", *tar_args
+
+# extract - can't use Gem::Package#extract_tar_gz from RubyGems
+# since it limits filenames to 100 characters (doesn't support UStar format)
+# for space, only keep licenses, include, and shared library
+Dir.mktmpdir do |extract_path|
+  tar_args = Gem.win_platform? ? ["--force-local"] : []
+  system "tar", "zxf", download_path, "-C", extract_path, "--strip-components=1", *tar_args
+
+  # licenses
+  license_files = Dir.glob("**/*{LICENSE,LICENCE,NOTICE,COPYING,license,licence,notice,copying}*", base: extract_path)
+  raise "License not found" unless license_files.any?
+  license_files.each do |file|
+    FileUtils.mkdir_p(File.join(path, File.dirname(file)))
+    FileUtils.cp(File.join(extract_path, file), File.join(path, file))
+  end
+
+  # include
+  FileUtils.cp_r(File.join(extract_path, "include"), File.join(path, "include"))
+
+  # shared library
+  FileUtils.mkdir(File.join(path, "lib"))
+  Dir.glob("lib/libortools.{dylib,so.9}", base: extract_path) do |file|
+    FileUtils.cp(File.join(extract_path, file), File.join(path, file))
+  end
+  so_path = File.join(path, "lib/libortools.so.9")
+  if File.exist?(so_path)
+    File.symlink(so_path, File.join(path, "lib/libortools.so"))
+  end
+end
 
 # export
 $vendor_path = path

data/lib/or_tools/cp_solver.rb

@@ -12,6 +12,12 @@ module ORTools
     end
 
     def value(var)
+      # could also check solution_size == 0
+      unless [:feasible, :optimal].include?(@response.status)
+        # could return nil, but raise error like Python library
+        raise Error, "No solution found"
+      end
+
       if var.is_a?(BoolVar)
         _solution_boolean_value(@response, var)
       else

data/lib/or_tools/linear_expr.rb

@@ -27,7 +27,11 @@ module ORTools
     end
 
     def *(other)
-      ProductCst.new(self, other)
+      if is_a?(Constant)
+        ProductCst.new(other, @val)
+      else
+        ProductCst.new(self, other)
+      end
     end
 
     def /(cst)
@@ -69,5 +73,13 @@ module ORTools
     def inspect
       "#<#{self.class.name} #{to_s}>"
     end
+
+    def coerce(other)
+      if other.is_a?(Numeric)
+        [Constant.new(other), self]
+      else
+        raise TypeError, "#{self.class} can't be coerced into #{other.class}"
+      end
+    end
   end
 end

data/lib/or_tools/mp_variable.rb

@@ -1,5 +1,5 @@
 module ORTools
-  # TODO change to VariableExpr in 0.7.0
+  # TODO change to VariableExpr in 0.8.0
   class MPVariable < LinearExpr
     def add_self_to_coeff_map_or_stack(coeffs, multiplier, stack)
       coeffs[self] += multiplier

data/lib/or_tools/solver.rb

@@ -9,17 +9,37 @@ module ORTools
     end
 
     def maximize(expr)
-      expr.coeffs.each do |v, c|
-        objective.set_coefficient(v, c)
-      end
+      set_objective(expr)
       objective.set_maximization
     end
 
     def minimize(expr)
-      expr.coeffs.each do |v, c|
+      set_objective(expr)
+      objective.set_minimization
+    end
+
+    private
+
+    def set_objective(expr)
+      objective.clear
+      coeffs = expr.coeffs
+      offset = coeffs.delete(OFFSET_KEY)
+      objective.set_offset(offset) if offset
+      coeffs.each do |v, c|
         objective.set_coefficient(v, c)
       end
-      objective.set_minimization
     end
+
+    # hack to work with Rice constructor
+    m = Module.new do
+      def new(solver_id, *args)
+        if args.empty?
+          _create(solver_id)
+        else
+          super
+        end
+      end
+    end
+    singleton_class.prepend(m)
   end
 end

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.6.2"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-09 00:00:00.000000000 Z
+date: 2022-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -75,7 +75,7 @@ files:
 - lib/or_tools/version.rb
 homepage: https://github.com/ankane/or-tools-ruby
 licenses:
-- MIT
+- Apache-2.0
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -92,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: Operations research tools for Ruby