or-tools 0.7.0 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03544e925041f7337e6e6ba1b00b6d6c4d97353bcd7ee3785a46959a952bf09c
-  data.tar.gz: eddbab6814900afc7ddda651da92a53aa06b0db857659ab2ccd1c1adb9770fe0
+  metadata.gz: d3cfb5b8fd7f6a4563b2d50a2357e4bfc72fc5ef69e2c7c1a6ad7e7736a66235
+  data.tar.gz: a1e2307c4a94495f9fe28e85e68171a9a3474a45ed98344250920360adffbd0f
 SHA512:
-  metadata.gz: '041939b99da310567a099f7654658697b93e36436abf06779336ca51e0d02be94473c0474d238041285975f293734cde65c37e5db565b8f30b49f856fe519100'
-  data.tar.gz: '09f6a2f0701acb005f356555df0d0e19befe36090d4de1b2188e7944a55836c80022eed5d4e185dc3b3b016c9c73fa3d5957e8c3cf8adf83bf4773b1090e5f0a'
+  metadata.gz: 8b62fd4b68b1a3b119d8da2987d263ad2fb0c4ca4d1062ef274f3dea440db62414af6188b769180a740a22898d26657569e71fefd0af9e754442061bcf481a1a
+  data.tar.gz: c4fbe636cd22654c867f25c954d1652540b54239a9427a7795033027a60ca7538b864e74c0134296040f57bf945750dbc80384965e7d449f9a5fb1474163ce9d

data/CHANGELOG.md

@@ -1,3 +1,11 @@
+## 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

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/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/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/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.7.0"
+  VERSION = "0.7.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.7.1
 platform: ruby
 authors:
 - Andrew Kane
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-03-23 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: []