or-tools 0.1.2 → 0.3.0

data/ext/or-tools/vendor.rb

@@ -0,0 +1,95 @@
+require "digest"
+require "fileutils"
+require "net/http"
+require "tmpdir"
+
+version = "7.7.7810"
+
+if RbConfig::CONFIG["host_os"] =~ /darwin/i
+  filename = "or-tools_MacOsX-10.15.5_v#{version}.tar.gz"
+  checksum = "764f290f6d916bc366913a37d93e6f83bd7969ad33515ccc1ca390f544d65721"
+else
+  os = %x[lsb_release -is].chomp rescue nil
+  os_version = %x[lsb_release -rs].chomp rescue nil
+  if os == "Ubuntu" && os_version == "18.04"
+    filename = "or-tools_ubuntu-18.04_v#{version}.tar.gz"
+    checksum = "12bdac29144b077b3f9ba602f947e4b9b9ce63ed3df4e325cda1333827edbcf8"
+  elsif os == "Ubuntu" && os_version == "16.04"
+    filename = "or-tools_ubuntu-16.04_v#{version}.tar.gz"
+    checksum = "cc696d342b97aa6cf7c62b6ae2cae95dfc665f2483d147c4117fdba434b13a53"
+  elsif os == "Debian" && os_version == "10"
+    filename = "or-tools_debian-10_v#{version}.tar.gz "
+    checksum = "3dd0299e9ad8d12fe6d186bfd59e63080c8e9f3c6b0489af9900c389cf7e4224"
+  elsif os == "CentOS" && os_version == "8"
+    filename = "or-tools_centos-8_v#{version}.tar.gz"
+    checksum = "1f7d8bce56807c4283374e05024ffac8afd81ff99063217418d02d626cf03088"
+  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

@@ -4,9 +4,11 @@ require "or_tools/ext"
 # modules
 require "or_tools/comparison"
 require "or_tools/comparison_operators"
+require "or_tools/bool_var"
 require "or_tools/cp_model"
 require "or_tools/cp_solver"
 require "or_tools/cp_solver_solution_callback"
+require "or_tools/int_var"
 require "or_tools/knapsack_solver"
 require "or_tools/linear_expr"
 require "or_tools/routing_model"
@@ -15,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/bool_var.rb

@@ -0,0 +1,9 @@
+module ORTools
+  class BoolVar
+    include ComparisonOperators
+
+    def *(other)
+      SatLinearExpr.new([[self, other]])
+    end
+  end
+end

data/lib/or_tools/cp_solver.rb

@@ -12,11 +12,20 @@ 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)
+      @response = _solve_with_observer(model, observer, false)
+      @response.status
     end
 
     def search_for_all_solutions(model, observer)
-      @response = _solve_with_observer(model, observer)
+      @response = _solve_with_observer(model, observer, true)
       @response.status
     end
   end

data/lib/or_tools/cp_solver_solution_callback.rb

@@ -3,7 +3,18 @@ module ORTools
     attr_writer :response
 
     def value(expr)
-      @response.solution_boolean_value(expr)
+      case expr
+      when SatIntVar
+        @response.solution_integer_value(expr)
+      when BoolVar
+        @response.solution_boolean_value(expr)
+      else
+        raise "Unsupported type"
+      end
+    end
+
+    def objective_value
+      @response.objective_value
     end
   end
 end

data/lib/or_tools/int_var.rb

@@ -0,0 +1,5 @@
+module ORTools
+  class IntVar
+    include ComparisonOperators
+  end
+end

data/lib/or_tools/linear_expr.rb

@@ -8,6 +8,14 @@ module ORTools
       end
     end
 
+    def >=(other)
+      if other.is_a?(LinearExpr)
+        _gte_linear_expr(other)
+      else
+        _gte_double(other)
+      end
+    end
+
     def <=(other)
       if other.is_a?(LinearExpr)
         _lte_linear_expr(other)

data/lib/or_tools/sat_int_var.rb

@@ -5,5 +5,18 @@ module ORTools
     def *(other)
       SatLinearExpr.new([[self, other]])
     end
+
+    def +(other)
+      SatLinearExpr.new([[self, 1], [other, 1]])
+    end
+
+    def -(other)
+      SatLinearExpr.new([[self, 1], [-other, 1]])
+    end
+
+    # for now
+    def inspect
+      name
+    end
   end
 end

data/lib/or_tools/sat_linear_expr.rb

@@ -16,8 +16,24 @@ module ORTools
       add(other, -1)
     end
 
+    def *(other)
+      if vars.size == 1
+        self.class.new([[vars[0][0], vars[0][1] * other]])
+      else
+        raise ArgumentError, "Multiplication not allowed here"
+      end
+    end
+
     def inspect
-      vars.map { |v| v[0].is_a?(BoolVar) ? v[0].name : v[0].name + " * " + v[1] }.join(" + ")
+      vars.map do |v|
+        k = v[0]
+        k = k.respond_to?(:name) ? k.name : k.inspect
+        if v[1] == 1
+          k
+        else
+          "#{k} * #{v[1]}"
+        end
+      end.join(" + ").sub(" + -", " - ")
     end
 
     private
@@ -27,7 +43,7 @@ module ORTools
         case other
         when SatLinearExpr
           other.vars
-        when BoolVar
+        when BoolVar, SatIntVar
           [[other, 1]]
         else
           raise ArgumentError, "Unsupported type"

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