whatnot 1.0

data/lib/whatnot/solution_enumerator.rb

@@ -0,0 +1,49 @@
+class SolutionEnumerator
+  include Enumerable
+
+  def initialize(solution_interpreter, dimacs="")
+    @dimacs = dimacs
+    @solution_interpreter = solution_interpreter
+  end
+
+  def next_solution
+    infile   = "/tmp/SolutionEnumerator-in.txt"
+    outfile  = "/tmp/SolutionEnumerator-out.txt"
+
+    File.open(infile, "w+") do |file|
+      file << @dimacs
+    end
+
+    `minisat -rnd-init -rnd-seed=#{Time.now.to_i} #{infile} #{outfile} 2>&1 >/dev/null`
+
+    File.read(outfile)
+  end
+
+  def each
+    solution = next_solution()
+
+    while solution.start_with?("SAT") do
+      clean_up_solution!(solution)
+
+      yield @solution_interpreter.call(solution)
+
+      @dimacs += ("\n" + inverse_of(solution))
+
+      solution = next_solution()
+    end
+  end
+
+  private
+
+  def clean_up_solution!(solution_string)
+    solution_string.gsub!(/\A(UN)?SAT\s/, "")
+    solution_string.gsub!(/\n\Z/, "")
+  end
+
+  def inverse_of(solution_string)
+    solution_string.
+      split(" ").
+      map { |num| (num.to_i * -1).to_s }.
+      join(" ")
+  end
+end

data/lib/whatnot/switch.rb

@@ -0,0 +1,39 @@
+class Switch
+  def self.next_number
+    @@next_number ||= 1
+  end
+
+  def self.inc_next_number!
+    @@next_number = @@next_number ? @@next_number + 1 : 1
+  end
+
+  def self.all
+    @@all ||= {}
+  end
+
+  def self.find(number)
+    all[number]
+  end
+
+  def self.add(switch)
+    switch.number = next_number
+    all[switch.number] = switch
+    inc_next_number!
+    switch
+  end
+
+  def self.each
+    all.values.each do |switch|
+      yield switch
+    end
+  end
+
+  extend Enumerable
+
+  def initialize(payload)
+    @payload = payload
+    Switch.add(self)
+  end
+
+  attr_accessor :number, :payload
+end

data/lib/whatnot/switch_group.rb

@@ -0,0 +1,151 @@
+class SwitchGroup
+  attr_accessor :switches, :possibilities
+
+  def initialize(nums=[], min_on: 1, max_on: 1)
+    @min_on = min_on
+    @max_on = max_on
+    @switches = []
+    @possibilities = []
+
+    if block_given?
+      Switch.each do |switch|
+        @switches << switch if yield(switch.payload)
+      end
+    else
+      @switches = Switch.all.values_at(*nums)
+    end
+
+    find_all_possibilities!
+  end
+
+  def find_all_possibilities!
+    switchmap = Hash[@switches.each_with_index.map { |s, ix| [s.number, ix+1] }]
+
+    groupdimacs = dimacs.lines.map do |line|
+      next if line.start_with?("c") || line.lstrip == ""
+
+      nums = line.split(" ").map(&:to_i)
+
+      newnums = []
+      nums.each do |n|
+        if n > 0
+          newnums << switchmap[n]
+        elsif n < 0
+          newnums << switchmap[n*-1] * -1
+        else
+          newnums << n
+        end
+      end
+
+      newnums.map(&:to_s).join(" ")
+    end
+
+    groupdimacs = groupdimacs.compact.join("\n")
+
+    groupinterpreter = -> (str) do
+      nums = str.split(" ").map(&:to_i)
+
+      newnums = []
+      nums.each do |n|
+        if n > 0
+          newnums << @switches[n-1].number
+        elsif n == 0
+          newnums << n
+        else
+          newnums << @switches[(-1*n)-1].number * -1
+        end
+      end
+
+      solution = newnums.map(&:to_s).join(" ")
+
+      [group_interpret(solution), solution]
+    end
+
+    if groupdimacs.empty?
+      # all solutions are possible, so iterate all.
+      # can't use minisat here (it won't know how many vars there are).
+      possibilities = {}
+
+      switch_combos = switches.map do |switch|
+        n = switch.number
+        [n, -1 * n]
+      end
+
+      switch_combos.inject(&:product).each do |product|
+        product = product.is_a?(Array) ? product.flatten : [product]
+        solution = product.map(&:to_s).join(" ") + " 0"
+        possibilities[group_interpret(solution)] = solution
+      end
+
+      @possibilities = possibilities
+    else
+      @possibilities = Hash[SolutionEnumerator.new(groupinterpreter, groupdimacs).entries]
+    end
+  end
+
+  def group_interpret(solution)
+    out = {}
+
+    solution.split(" ").each do |num|
+      num = num.to_i
+
+      if num > 0
+        merge_payload!(for_num: num, to_hash: out)
+      end
+    end
+
+    out
+  end
+
+  def merge_payload!(for_num: nil, to_hash: nil)
+    if for_num.nil? || to_hash.nil?
+      raise "left off required kwargs #{"for_num, " unless for_num}#{"to_hash" unless to_hash}" 
+    end
+
+    payload = Switch.find(for_num).payload
+    payload_key, payload_val = *payload.to_a[0]
+
+    # manage sets vs. slots
+    if @max_on > 1
+      payload_val = [payload_val] unless payload_val.is_a?(Array)
+
+      if to_hash[payload_key]
+        to_hash[payload_key] += payload_val
+      else
+        to_hash[payload_key] = payload_val
+      end
+
+      return to_hash
+    end
+
+    to_hash.merge!(payload)
+  end
+
+  def dimacs
+    r = ""
+
+    r << "c Switches:\n"
+    @switches.each do |switch|
+      switch_pp = switch.payload.pretty_inspect.lines
+      r << "c   #{switch.number}: #{switch_pp[0]}"
+      switch_pp[1..-1].each do |line|
+        r << "c     #{line}"
+      end
+    end
+
+    if @min_on > 0
+      @switches.combination(@switches.size - (@min_on-1)).each do |combo|
+        r << combo.map(&:number).map(&:to_s).join(" ") + " 0\n"
+      end
+    end
+
+    if @max_on < @switches.size
+      @switches.combination(@max_on+1).each do |combo|
+        r << combo.map(&:number).map { |s| "-#{s}" }.join(" ") + " 0\n"
+      end
+    end
+
+    r << "\n\n"
+    r
+  end
+end

data/lib/whatnot/switch_interpreter.rb

@@ -0,0 +1,211 @@
+class SwitchInterpreter
+  class NameCollisionError < ::RuntimeError
+    def initialize(info="")
+      super("Already using name #{info}")
+    end
+  end
+
+  attr_accessor :set_groups, :slot_groups, :non_interpreted_groups
+
+  def initialize
+    Switch.class_variable_set(:@@all, {})
+    Switch.class_variable_set(:@@next_number, 1)
+    @slot_groups = {}
+    @set_groups  = {}
+    @non_interpreted_groups = {}
+  end
+
+  def interpreted_groups
+    groups = {}
+    groups.merge! @slot_groups
+    groups.merge! @set_groups
+    groups
+  end
+
+  def dimacs
+    d = "c SwitchInterpreter\np cnf 1 1\n"
+    d << "\n"
+
+    interpreted_groups.to_a.each do |key, group|
+      d << "c ---------------------------\n"
+      d << "c INTERPRETED\n"
+      d << "c #{group.class} => \n"
+      d << "c   #{key}\n"
+      d << "c \n"
+      d << group.dimacs
+    end
+
+    @non_interpreted_groups.to_a.each do |key, group|
+      d << "c ---------------------------\n"
+      d << "c NON-INTERPRETED\n"
+      d << "c #{group.class} => \n"
+      d << "c   #{key}\n"
+      d << "c \n"
+      d << group.dimacs
+    end
+
+    d
+  end
+
+  def merge_payload!(for_num: nil, to_hash: nil)
+    if for_num.nil? || to_hash.nil?
+      raise "left off required kwargs #{"for_num, " unless for_num}#{"to_hash" unless to_hash}" 
+    end
+
+    payload = Switch.find(for_num).payload
+    payload_key, payload_val = *payload.to_a[0]
+
+    # manage sets vs. slots
+    if @set_groups[payload_key]
+      payload_val = [payload_val] unless payload_val.is_a?(Array)
+
+      if to_hash[payload_key]
+        to_hash[payload_key] += payload_val
+      else
+        to_hash[payload_key] = payload_val
+      end
+
+      return to_hash
+    end
+
+    to_hash.merge!(payload)
+  end
+
+  def create_slot(slotname, slotvalues, allow_empty: true)
+    if interpreted_groups[slotname]
+      raise NameCollisionError.new(slotname)
+    end
+
+    numbers = []
+
+    [slotname].product(slotvalues).each do |name, value|
+      s = Switch.new({name => value})
+      numbers << s.number
+    end
+
+    min_on = allow_empty ? 0 : 1
+
+    @slot_groups[slotname] = SwitchGroup.new(numbers, min_on: min_on, max_on: 1)
+  end
+
+  def create_set(setname, setvalues, allow_empty: true, max_values: 2)
+    if interpreted_groups[setname]
+      raise NameCollisionError.new(setname)
+    end
+
+    numbers = []
+
+    [setname].product(setvalues).each do |name, value|
+      s = Switch.new({name => value})
+      numbers << s.number
+    end
+
+    min_on = allow_empty ? 0 : 1
+
+    @set_groups[setname] = SwitchGroup.new(numbers, min_on: min_on, max_on: max_values)
+  end
+
+  def create_mutually_exclusive_slots(slotnames, slotvalues, allow_empty: false)
+    begin
+      slotnames.each do |slotname|
+        create_slot(slotname, slotvalues, allow_empty: allow_empty)
+      end
+    rescue NameCollisionError
+    end
+
+    slotvalues.each do |slotvalue|
+      mutual_exclusion = SwitchGroup.new(nil, min_on: 0, max_on: 1) do |payload|
+        k, v = *payload.to_a[0]
+        slotnames.include?(k) && slotvalue == v
+      end
+
+      @non_interpreted_groups[slotvalue] = mutual_exclusion
+    end
+  end
+
+  def create_mutually_exclusive_sets(slotnames, slotvalues, allow_empty: true, require_complete: true, max_values: 2)
+    begin
+      slotnames.each do |slotname|
+        create_set(slotname, slotvalues, allow_empty: allow_empty, max_values: max_values)
+      end
+    rescue NameCollisionError
+    end
+
+    slotvalues.each do |slotvalue|
+      min_on = require_complete ? 1 : 0
+
+      mutual_exclusion = SwitchGroup.new(nil, min_on: min_on, max_on: 1) do |payload|
+        k, v = *payload.to_a[0]
+        slotnames.include?(k) && slotvalue == v
+      end
+
+      @non_interpreted_groups[slotvalue] = mutual_exclusion
+    end
+  end
+
+  def create_constraint(*slotnames)
+    solutions_to_try = nil
+
+    slotnames.each do |groupname|
+      group = interpreted_groups[groupname]
+
+      if group.nil?
+        group = @non_interpreted_groups[groupname]
+      end
+
+      raise "can't find group #{groupname}" if group.nil?
+
+      # get possible solutions for each group
+      group_solutions = group.possibilities
+
+      merge_possibilities = -> (p1, p2) do
+        Hash[p1.to_a.product(p2.to_a).map { |prod| [prod.map(&:first).inject(&:merge), prod.map(&:last).inject("") { |memo, d| memo + d[0..-2] } + "0"] }]
+      end
+
+      if solutions_to_try
+        solutions_to_try = merge_possibilities.call(solutions_to_try, group_solutions)
+      else
+        solutions_to_try = group_solutions
+      end
+    end
+
+    # get source of constraint in user code
+    trace = Thread.current.backtrace
+    interpreter_lines = []
+    trace.each.with_index do |line, ix|
+      if line.match(/switch_interpreter.rb/)
+        interpreter_lines << ix
+      end
+    end
+    line_of_caller = trace[interpreter_lines.max + 1].split("/").last
+    failed_solution_strings = []
+
+    solutions_to_try.each do |solution, solution_str|
+      result = yield(**solution)
+
+      if !result
+        failed_solution_strings << solution_str
+      end
+    end
+
+    if constraint_group = @non_interpreted_groups[line_of_caller]
+      constraint_group.failed_solutions += failed_solution_strings
+    else
+      @non_interpreted_groups[line_of_caller] = FailedSolutionSwitchGroup.new(failed_solution_strings)
+    end
+  end
+
+  def interpret(solution)
+    out = {}
+
+    solution.split(" ").each do |num|
+      num = num.to_i
+
+      if num > 0
+        merge_payload!(for_num: num, to_hash: out)
+      end
+    end
+
+    out
+  end
+end