or-tools 0.1.2 → 0.3.0

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

data/lib/or_tools/tsp.rb

@@ -0,0 +1,60 @@
+module ORTools
+  class TSP
+    attr_reader :route, :route_indexes, :distances, :total_distance
+
+    DISTANCE_SCALE = 1000
+    DEGREES_TO_RADIANS = Math::PI / 180
+
+    def initialize(locations)
+      raise ArgumentError, "Locations must have latitude and longitude" unless locations.all? { |l| l[:latitude] && l[:longitude] }
+      raise ArgumentError, "Latitude must be between -90 and 90" unless locations.all? { |l| l[:latitude] >= -90 && l[:latitude] <= 90 }
+      raise ArgumentError, "Longitude must be between -180 and 180" unless locations.all? { |l| l[:longitude] >= -180 && l[:longitude] <= 180 }
+      raise ArgumentError, "Must be at least two locations" unless locations.size >= 2
+
+      distance_matrix =
+        locations.map do |from|
+          locations.map do |to|
+            # must be integers
+            (distance(from, to) * DISTANCE_SCALE).to_i
+          end
+        end
+
+      manager = ORTools::RoutingIndexManager.new(locations.size, 1, 0)
+      routing = ORTools::RoutingModel.new(manager)
+
+      distance_callback = lambda do |from_index, to_index|
+        from_node = manager.index_to_node(from_index)
+        to_node = manager.index_to_node(to_index)
+        distance_matrix[from_node][to_node]
+      end
+
+      transit_callback_index = routing.register_transit_callback(distance_callback)
+      routing.set_arc_cost_evaluator_of_all_vehicles(transit_callback_index)
+      assignment = routing.solve(first_solution_strategy: :path_cheapest_arc)
+
+      @route_indexes = []
+      @distances = []
+
+      index = routing.start(0)
+      while !routing.end?(index)
+        @route_indexes << manager.index_to_node(index)
+        previous_index = index
+        index = assignment.value(routing.next_var(index))
+        @distances << routing.arc_cost_for_vehicle(previous_index, index, 0) / DISTANCE_SCALE.to_f
+      end
+      @route_indexes << manager.index_to_node(index)
+      @route = locations.values_at(*@route_indexes)
+      @total_distance = @distances.sum
+    end
+
+    private
+
+    def distance(from, to)
+      from_lat = from[:latitude] * DEGREES_TO_RADIANS
+      from_lng = from[:longitude] * DEGREES_TO_RADIANS
+      to_lat = to[:latitude] * DEGREES_TO_RADIANS
+      to_lng = to[:longitude] * DEGREES_TO_RADIANS
+      2 * 6371 * Math.asin(Math.sqrt(Math.sin((to_lat - from_lat) / 2.0)**2 + Math.cos(from_lat) * Math.cos(to_lat) * Math.sin((from_lng - to_lng) / 2.0)**2))
+    end
+  end
+end

data/lib/or_tools/version.rb

@@ -1,3 +1,3 @@
 module ORTools
-  VERSION = "0.1.2"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: or-tools
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Andrew Kane
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-18 00:00:00.000000000 Z
+date: 2020-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rice
@@ -93,19 +93,26 @@ files:
 - README.md
 - ext/or-tools/ext.cpp
 - ext/or-tools/extconf.rb
+- ext/or-tools/vendor.rb
 - lib/or-tools.rb
+- lib/or_tools/basic_scheduler.rb
+- lib/or_tools/bool_var.rb
 - lib/or_tools/comparison.rb
 - lib/or_tools/comparison_operators.rb
 - lib/or_tools/cp_model.rb
 - lib/or_tools/cp_solver.rb
 - lib/or_tools/cp_solver_solution_callback.rb
 - lib/or_tools/ext.bundle
+- lib/or_tools/int_var.rb
 - lib/or_tools/knapsack_solver.rb
 - lib/or_tools/linear_expr.rb
 - lib/or_tools/routing_model.rb
 - lib/or_tools/sat_int_var.rb
 - lib/or_tools/sat_linear_expr.rb
+- lib/or_tools/seating.rb
 - lib/or_tools/solver.rb
+- lib/or_tools/sudoku.rb
+- lib/or_tools/tsp.rb
 - lib/or_tools/version.rb
 homepage: https://github.com/ankane/or-tools
 licenses: