or-tools 0.1.4 → 0.3.2

data/ext/or-tools/ext.cpp

@@ -661,6 +661,11 @@ void Init_ext()
       "_solution_integer_value",
       *[](Object self, CpSolverResponse& response, operations_research::sat::IntVar& x) {
         return SolutionIntegerValue(response, x);
+      })
+    .define_method(
+      "_solution_boolean_value",
+      *[](Object self, CpSolverResponse& response, operations_research::sat::BoolVar& x) {
+        return SolutionBooleanValue(response, x);
       });
 
   define_class_under<CpSolverResponse>(rb_mORTools, "CpSolverResponse")

data/ext/or-tools/extconf.rb

@@ -1,6 +1,6 @@
 require "mkmf-rice"
 
-abort "Missing stdc++" unless have_library("stdc++")
+raise "Missing stdc++" unless have_library("stdc++")
 
 $CXXFLAGS << " -std=c++11 -DUSE_CBC"
 
@@ -8,73 +8,31 @@ $CXXFLAGS << " -std=c++11 -DUSE_CBC"
 $CXXFLAGS << " -Wno-sign-compare -Wno-shorten-64-to-32 -Wno-ignored-qualifiers"
 
 inc, lib = dir_config("or-tools")
-
-inc ||= "/usr/local/include"
-lib ||= "/usr/local/lib"
+if inc || lib
+  inc ||= "/usr/local/include"
+  lib ||= "/usr/local/lib"
+  rpath = lib
+else
+  # download
+  require_relative "vendor"
+
+  inc = "#{$vendor_path}/include"
+  lib = "#{$vendor_path}/lib"
+
+  # make rpath relative
+  # use double dollar sign and single quotes to escape properly
+  rpath_prefix = RbConfig::CONFIG["host_os"] =~ /darwin/ ? "@loader_path" : "$$ORIGIN"
+  rpath = "'#{rpath_prefix}/../../tmp/or-tools/lib'"
+end
 
 $INCFLAGS << " -I#{inc}"
 
-$LDFLAGS << " -Wl,-rpath,#{lib}"
+$LDFLAGS << " -Wl,-rpath,#{rpath}"
 $LDFLAGS << " -L#{lib}"
-$LDFLAGS << " -lortools"
+raise "OR-Tools not found" unless have_library("ortools")
 
-%w(
-  absl_city
-  absl_time_zone
-  absl_spinlock_wait
-  absl_log_severity
-  absl_failure_signal_handler
-  absl_bad_optional_access
-  absl_hash
-  absl_raw_logging_internal
-  absl_random_internal_pool_urbg
-  absl_base
-  absl_bad_any_cast_impl
-  absl_periodic_sampler
-  absl_random_distributions
-  absl_flags_usage_internal
-  absl_random_seed_sequences
-  absl_throw_delegate
-  absl_flags_handle
-  absl_dynamic_annotations
-  absl_debugging_internal
-  absl_strings
-  absl_flags
-  absl_malloc_internal
-  absl_str_format_internal
-  absl_flags_usage
-  absl_strings_internal
-  absl_flags_program_name
-  absl_flags_registry
-  absl_int128
-  absl_scoped_set_env
-  absl_raw_hash_set
-  absl_random_internal_seed_material
-  absl_symbolize
-  absl_random_internal_randen_slow
-  absl_graphcycles_internal
-  absl_exponential_biased
-  absl_random_internal_randen_hwaes_impl
-  absl_bad_variant_access
-  absl_stacktrace
-  absl_random_internal_randen_hwaes
-  absl_flags_parse
-  absl_random_internal_randen
-  absl_random_internal_distribution_test_util
-  absl_time
-  absl_flags_config
-  absl_synchronization
-  absl_hashtablez_sampler
-  absl_demangle_internal
-  absl_leak_check
-  absl_flags_marshalling
-  absl_leak_check_disable
-  absl_examine_stack
-  absl_flags_internal
-  absl_random_seed_gen_exception
-  absl_civil_time
-).each do |lib|
-  $LDFLAGS << " -l#{lib}"
+Dir["#{lib}/libabsl_*.a"].each do |lib|
+  $LDFLAGS << " #{lib}"
 end
 
 create_makefile("or_tools/ext")

data/ext/or-tools/vendor.rb

@@ -0,0 +1,98 @@
+require "digest"
+require "fileutils"
+require "net/http"
+require "tmpdir"
+
+version = "7.8.7959"
+
+if RbConfig::CONFIG["host_os"] =~ /darwin/i
+  filename = "or-tools_MacOsX-10.15.6_v#{version}.tar.gz"
+  checksum = "8d1d92105e962fab2fd7bde5843b711334a9f246dc22c51d41281898dbc1f69d"
+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 = "40018cd573305cec76e12ff87e84d4ec18ce0823f265e4d75625bf3aefdea7c9"
+  elsif os == "Ubuntu" && os_version == "18.04"
+    filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
+    checksum = "6e53e1a7b82b65b928617b9dce663778c5200de9366ad948948597dc763b1943"
+  elsif os == "Ubuntu" && os_version == "16.04"
+    filename = "or-tools_ubuntu-16.04_v#{version}.tar.gz"
+    checksum = "182cd4e2a1d2f29a9a81f2f90cb3e05cf1c0731c1a1e94c471d79a74dc09fff0"
+  elsif os == "Debian" && os_version == "10"
+    filename = "or-tools_debian-10_v#{version}.tar.gz "
+    checksum = "87dd294237095a7fea466c47789802b0a66c664fa1f79e6bbb2cd36323b409ca"
+  elsif os == "CentOS" && os_version == "8"
+    filename = "or-tools_centos-8_v#{version}.tar.gz"
+    checksum = "4e61bf2994fc767da1b4fd073f554c944d2c811609df4bc1afa6a2d876c05bb4"
+  else
+    # there is a binary download for Windows
+    # however, it's compiled with Visual Studio rather than MinGW (which RubyInstaller uses)
+    raise <<~MSG
+      Binary installation not available for this platform.
+
+      Build the OR-Tools C++ library from source, then run:
+      bundle config build.or-tools --with-or-tools-dir=/path/to/or-tools
+
+    MSG
+  end
+end
+
+short_version = version.split(".").first(2).join(".")
+url = "https://github.com/google/or-tools/releases/download/v#{short_version}/#{filename}"
+
+$stdout.sync = true
+
+def download_file(url, download_path)
+  uri = URI(url)
+  location = nil
+
+  Net::HTTP.start(uri.host, uri.port, use_ssl: true) do |http|
+    request = Net::HTTP::Get.new(uri)
+    http.request(request) do |response|
+      case response
+      when Net::HTTPRedirection
+        location = response["location"]
+      when Net::HTTPSuccess
+        i = 0
+        File.open(download_path, "wb") do |f|
+          response.read_body do |chunk|
+            f.write(chunk)
+
+            # print progress
+            putc "." if i % 50 == 0
+            i += 1
+          end
+        end
+        puts # newline
+      else
+        raise "Bad response"
+      end
+    end
+  end
+
+  # outside of Net::HTTP block to close previous connection
+  download_file(location, download_path) if location
+end
+
+# download
+download_path = "#{Dir.tmpdir}/#{filename}"
+unless File.exist?(download_path)
+  puts "Downloading #{url}..."
+  download_file(url, download_path)
+end
+
+# check integrity - do this regardless of if just downloaded
+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
+
+# export
+$vendor_path = path

data/lib/or-tools.rb

@@ -17,6 +17,12 @@ require "or_tools/sat_int_var"
 require "or_tools/solver"
 require "or_tools/version"
 
+# higher level interfaces
+require "or_tools/basic_scheduler"
+require "or_tools/seating"
+require "or_tools/sudoku"
+require "or_tools/tsp"
+
 module ORTools
   class Error < StandardError; end
 end

data/lib/or_tools/basic_scheduler.rb

@@ -0,0 +1,86 @@
+module ORTools
+  class BasicScheduler
+    attr_reader :assignments, :assigned_hours
+
+    # for time blocks (shifts and availability)
+    # could also use time range (starts_at..ends_at) or starts_at + duration
+    # keep current format for now for flexibility
+    def initialize(people:, shifts:)
+      @shifts = shifts
+
+      model = ORTools::CpModel.new
+
+      # create variables
+      # a person must be available for the entire shift to be considered for it
+      vars = []
+      shifts.each_with_index do |shift, i|
+        people.each_with_index do |person, j|
+          if person[:availability].any? { |a| a[:starts_at] <= shift[:starts_at] && a[:ends_at] >= shift[:ends_at] }
+            vars << {shift: i, person: j, var: model.new_bool_var("{shift: #{i}, person: #{j}}")}
+          end
+        end
+      end
+
+      vars_by_shift = vars.group_by { |v| v[:shift] }
+      vars_by_person = vars.group_by { |v| v[:person] }
+
+      # one person per shift
+      vars_by_shift.each do |j, vs|
+        model.add(model.sum(vs.map { |v| v[:var] }) <= 1)
+      end
+
+      # one shift per day per person
+      # in future, may also want to add option to ensure assigned shifts are N hours apart
+      vars_by_person.each do |j, vs|
+        vs.group_by { |v| shift_dates[v[:shift]] }.each do |_, vs2|
+          model.add(model.sum(vs2.map { |v| v[:var] }) <= 1)
+        end
+      end
+
+      # max hours per person
+      # use seconds since model needs integers
+      vars_by_person.each do |j, vs|
+        max_hours = people[j][:max_hours]
+        if max_hours
+          model.add(model.sum(vs.map { |v| v[:var] * shift_duration[v[:shift]] }) <= max_hours * 3600)
+        end
+      end
+
+      # maximize hours assigned
+      # could also include distance from max hours
+      model.maximize(model.sum(vars.map { |v| v[:var] * shift_duration[v[:shift]] }))
+
+      # solve
+      solver = ORTools::CpSolver.new
+      status = solver.solve(model)
+      raise Error, "No solution found" unless [:feasible, :optimal].include?(status)
+
+      # read solution
+      @assignments = []
+      vars.each do |v|
+        if solver.value(v[:var])
+          @assignments << {
+            person: v[:person],
+            shift: v[:shift]
+          }
+        end
+      end
+      # can calculate manually if objective changes
+      @assigned_hours = solver.objective_value / 3600.0
+    end
+
+    def total_hours
+      @total_hours ||= shift_duration.sum / 3600.0
+    end
+
+    private
+
+    def shift_duration
+      @shift_duration ||= @shifts.map { |s| (s[:ends_at] - s[:starts_at]).round }
+    end
+
+    def shift_dates
+      @shift_dates ||= @shifts.map { |s| s[:starts_at].to_date }
+    end
+  end
+end

data/lib/or_tools/cp_solver.rb

@@ -12,7 +12,11 @@ module ORTools
     end
 
     def value(var)
-      _solution_integer_value(@response, var)
+      if var.is_a?(BoolVar)
+        _solution_boolean_value(@response, var)
+      else
+        _solution_integer_value(@response, var)
+      end
     end
 
     def solve_with_solution_callback(model, observer)

data/lib/or_tools/seating.rb

@@ -0,0 +1,115 @@
+module ORTools
+  class Seating
+    attr_reader :assignments, :people, :total_weight
+
+    def initialize(connections:, tables:, min_connections: 1)
+      @people = connections.flat_map { |c| c[:people] }.uniq
+
+      @connections_for = {}
+      @people.each do |person|
+        @connections_for[person] = {}
+      end
+      connections.each do |c|
+        c[:people].each_with_index do |person, i|
+          others = c[:people].dup
+          others.delete_at(i)
+          others.each do |other|
+            @connections_for[person][other] ||= 0
+            @connections_for[person][other] += c[:weight]
+          end
+        end
+      end
+
+      model = ORTools::CpModel.new
+      all_tables = tables.size.times.to_a
+
+      # decision variables
+      seats = {}
+      all_tables.each do |t|
+        people.each do |g|
+          seats[[t, g]] = model.new_bool_var("guest %s seats on table %i" % [g, t])
+        end
+      end
+
+      pairs = people.combination(2)
+
+      colocated = {}
+      pairs.each do |g1, g2|
+        colocated[[g1, g2]] = model.new_bool_var("guest %s seats with guest %s" % [g1, g2])
+      end
+
+      same_table = {}
+      pairs.each do |g1, g2|
+        all_tables.each do |t|
+          same_table[[g1, g2, t]] = model.new_bool_var("guest %s seats with guest %s on table %i" % [g1, g2, t])
+        end
+      end
+
+      # objective
+      objective = []
+      pairs.each do |g1, g2|
+        weight = @connections_for[g1][g2]
+        objective << colocated[[g1, g2]] * weight if weight
+      end
+      model.maximize(model.sum(objective))
+
+      # everybody seats at one table
+      people.each do |g|
+        model.add(model.sum(all_tables.map { |t| seats[[t, g]] }) == 1)
+      end
+
+      # tables have a max capacity
+      all_tables.each do |t|
+        model.add(model.sum(@people.map { |g| seats[[t, g]] }) <= tables[t])
+      end
+
+      # link colocated with seats
+      pairs.each do |g1, g2|
+        all_tables.each do |t|
+          # link same_table and seats
+          model.add_bool_or([seats[[t, g1]].not, seats[[t, g2]].not, same_table[[g1, g2, t]]])
+          model.add_implication(same_table[[g1, g2, t]], seats[[t, g1]])
+          model.add_implication(same_table[[g1, g2, t]], seats[[t, g2]])
+        end
+
+        # link colocated and same_table
+        model.add(model.sum(all_tables.map { |t| same_table[[g1, g2, t]] }) == colocated[[g1, g2]])
+      end
+
+      # min known neighbors rule
+      same_table_by_person = Hash.new { |hash, key| hash[key] = [] }
+      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
+      end
+      same_table_by_person.each do |_, vars|
+        model.add(model.sum(vars) >= min_connections)
+      end
+
+      # solve
+      solver = ORTools::CpSolver.new
+      status = solver.solve(model)
+      raise Error, "No solution found" unless [:feasible, :optimal].include?(status)
+
+      # read solution
+      @assignments = {}
+      seats.each do |k, v|
+        if solver.value(v)
+          @assignments[k[1]] = k[0]
+        end
+      end
+      @total_weight = solver.objective_value
+    end
+
+    def assigned_tables
+      assignments.group_by { |_, v| v }.map { |k, v| [k, v.map(&:first)] }.sort_by(&:first).map(&:last)
+    end
+
+    def connections_for(person, same_table: false)
+      result = @connections_for[person]
+      result = result.select { |k, _| @assignments[k] == @assignments[person] } if same_table
+      result
+    end
+  end
+end

data/lib/or_tools/sudoku.rb

@@ -0,0 +1,132 @@
+module ORTools
+  class Sudoku
+    attr_reader :solution
+
+    def initialize(initial_grid, x: false, magic_square: false, anti_knight: false, anti_king: false, non_consecutive: false)
+      raise ArgumentError, "Grid must be 9x9" unless initial_grid.size == 9 && initial_grid.all? { |r| r.size == 9 }
+      raise ArgumentError, "Grid must contain values between 0 and 9" unless initial_grid.flatten(1).all? { |v| (0..9).include?(v) }
+
+      model = ORTools::CpModel.new
+
+      cell_size = 3
+      line_size = cell_size**2
+      line = (0...line_size).to_a
+      cell = (0...cell_size).to_a
+
+      grid = {}
+      line.each do |i|
+        line.each do |j|
+          grid[[i, j]] = model.new_int_var(1, line_size, "grid %i %i" % [i, j])
+        end
+      end
+
+      line.each do |i|
+        model.add_all_different(line.map { |j| grid[[i, j]] })
+      end
+
+      line.each do |j|
+        model.add_all_different(line.map { |i| grid[[i, j]] })
+      end
+
+      cell.each do |i|
+        cell.each do |j|
+          one_cell = []
+          cell.each do |di|
+            cell.each do |dj|
+              one_cell << grid[[i * cell_size + di, j * cell_size + dj]]
+            end
+          end
+          model.add_all_different(one_cell)
+        end
+      end
+
+      line.each do |i|
+        line.each do |j|
+          if initial_grid[i][j] != 0
+            model.add(grid[[i, j]] == initial_grid[i][j])
+          end
+        end
+      end
+
+      if x
+        model.add_all_different(9.times.map { |i| grid[[i, i]] })
+        model.add_all_different(9.times.map { |i| grid[[i, 8 - i]] })
+      end
+
+      if magic_square
+        magic_sums = []
+        3.times do |i|
+          magic_sums << model.sum(3.times.map { |j| grid[[3 + i, 3 + j]] })
+          magic_sums << model.sum(3.times.map { |j| grid[[3 + j, 3 + i]] })
+        end
+
+        magic_sums << model.sum(3.times.map { |i| grid[[3 + i, 3 + i]] })
+        magic_sums << model.sum(3.times.map { |i| grid[[3 + i, 5 - i]] })
+
+        first_sum = magic_sums.shift
+        magic_sums.each do |magic_sum|
+          model.add(magic_sum == first_sum)
+        end
+      end
+
+      if anti_knight
+        # add anti-knights rule
+        # for each square, add squares that cannot be feasible
+        moves = [[1, 2], [2, 1], [2, -1], [1, -2], [-1, -2], [-2, -1], [-2, 1], [-1, 2]]
+        9.times do |i|
+          9.times do |j|
+            moves.each do |mi, mj|
+              square = grid[[i + mi, j + mj]]
+              if square
+                model.add(grid[[i, j]] != square)
+              end
+            end
+          end
+        end
+      end
+
+      if anti_king
+        # add anti-king rule
+        # for each square, add squares that cannot be feasible
+        moves = [[1, 0], [1, 1], [0, 1], [-1, 1], [-1, 0], [-1, -1], [0, -1], [1, -1]]
+        9.times do |i|
+          9.times do |j|
+            moves.each do |mi, mj|
+              square = grid[[i + mi, j + mj]]
+              if square
+                model.add(grid[[i, j]] != square)
+              end
+            end
+          end
+        end
+      end
+
+      if non_consecutive
+        # add non-consecutive rule
+        # for each square, add squares that cannot be feasible
+        moves = [[1, 0], [0, 1], [-1, 0], [0, -1]]
+        9.times do |i|
+          9.times do |j|
+            moves.each do |mi, mj|
+              square = grid[[i + mi, j + mj]]
+              if square
+                model.add(grid[[i, j]] + 1 != square)
+                model.add(grid[[i, j]] - 1 != square)
+              end
+            end
+          end
+        end
+      end
+
+      solver = ORTools::CpSolver.new
+      status = solver.solve(model)
+      raise Error, "No solution found" unless [:feasible, :optimal].include?(status)
+
+      solution = []
+      line.each do |i|
+        solution << line.map { |j| solver.value(grid[[i, j]]) }
+      end
+      @solution = solution
+    end
+  end
+end