whatnot 1.0

data/lib/whatnot/version.rb

@@ -0,0 +1,3 @@
+module Whatnot
+  VERSION = 1.0
+end

data/spec/lib/whatnot/dimacs_cnf_var_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+module Whatnot
+  describe DimacsCNFVar do
+    let(:test_table) do
+      {:name=>:Y5A3T3,
+       :domain=>
+        [{:kid_ids=>[2, 10, 11],
+          :subject_ids=>[4, 3, 2, 1],
+          :grade_id=>1,
+          :hosting_slot=>:A1H1,
+          :class_id=>1,
+          :day=>5},
+         {:kid_ids=>[2, 10, 11],
+          :subject_ids=>[4, 3, 2, 1],
+          :grade_id=>1,
+          :hosting_slot=>:A2H1,
+          :class_id=>4,
+          :day=>5},
+         {:kid_ids=>[2, 10, 11],
+          :subject_ids=>[4, 3, 2, 1],
+          :grade_id=>1,
+          :hosting_slot=>:A2H2,
+          :class_id=>7,
+          :day=>5},
+         {:null_class=>1},
+         {:null_class=>2},
+         {:null_class=>3},
+         {:null_class=>4}],
+       :argument_set=>
+        [[{:kid_ids=>[2, 10, 11],
+           :subject_ids=>[4, 3, 2, 1],
+           :grade_id=>1,
+           :hosting_slot=>"A1H1",
+           :class_id=>1,
+           :day=>5},
+          579],
+         [{:kid_ids=>[2, 10, 11],
+           :subject_ids=>[4, 3, 2, 1],
+           :grade_id=>1,
+           :hosting_slot=>"A2H1",
+           :class_id=>4,
+           :day=>5},
+          580],
+         [{:kid_ids=>[2, 10, 11],
+           :subject_ids=>[4, 3, 2, 1],
+           :grade_id=>1,
+           :hosting_slot=>"A2H2",
+           :class_id=>7,
+           :day=>5},
+          581],
+         [{:null_class=>1}, 582],
+         [{:null_class=>2}, 583],
+         [{:null_class=>3}, 584],
+         [{:null_class=>4}, 585]]}
+    end
+
+    describe '#argument_set' do
+      it 'works' do
+        var = DimacsCNFVar.new(test_table[:name], test_table[:domain], key_iter: 579)
+        expect(var.argument_set).to eq(test_table[:argument_set])
+      end
+    end
+  end
+end

data/spec/lib/whatnot/solution_enumerator_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Whatnot
+  describe SolutionEnumerator do
+    def noop(str); str end
+
+    describe "#each" do
+      context "simplest" do
+        let(:dimacs) do
+          %(
+          c Test DIMACS 1
+          c -------------
+          p cnf 2 2
+          1 -2 0
+          -1 2 0
+          )
+        end
+
+        let(:interpreter) { method(:noop) }
+
+        it "finds all solutions" do
+          enum = SolutionEnumerator.new(interpreter, dimacs)
+
+          expect(enum.entries).to eq(["-1 -2 0", "1 2 0"])
+        end
+      end
+
+      context "with SwitchGroup" do
+        before do
+          Switch.class_variable_set(:"@@all", {})
+          Switch.class_variable_set(:"@@next_number", 1)
+          Switch.new({foo: 1})
+          Switch.new({foo: 2})
+          Switch.new({foo: 3})
+        end
+
+        let(:interpreter) { method(:noop) }
+
+        it "finds all solutions" do
+          group = SwitchGroup.new(max_on: 2) { true }
+          enum = SolutionEnumerator.new(interpreter, group.dimacs)
+          expect(enum.entries).to eq(["-1 -2 3 0", "1 -2 -3 0", "-1 2 -3 0", "1 2 -3 0", "-1 2 3 0", "1 -2 3 0"])
+        end
+      end
+    end
+  end
+end

data/spec/lib/whatnot/switch_group_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+
+module Whatnot
+  describe SwitchGroup do
+    describe "dimacs" do
+      let(:min_one_max_one_dimacs) do
+        %(1 2 3 0
+          -1 -2 0
+          -1 -3 0
+          -2 -3 0).lines.map(&:strip).join("\n") + "\n"
+      end
+
+      let(:min_two_max_two_dimacs) do
+        %(1 2 0
+          1 3 0
+          2 3 0
+          -1 -2 -3 0).lines.map(&:strip).join("\n") + "\n"
+      end
+
+      let(:min_zero_max_two_dimacs) do
+        %(-1 -2 -3 0).lines.map(&:strip).join("\n") + "\n"
+      end
+
+      let(:min_one_max_two_dimacs) do
+        %(1 2 3 0
+          -1 -2 -3 0).lines.map(&:strip).join("\n") + "\n"
+      end
+
+      before do
+        Switch.class_variable_set(:"@@all", {})
+        Switch.class_variable_set(:"@@next_number", 1)
+        Switch.new({foo: 1})
+        Switch.new({foo: 2})
+        Switch.new({foo: 3})
+      end
+
+      context "simplest" do
+        it "produces correct clauses" do
+
+          group = SwitchGroup.new { true }
+          expect(group.dimacs).to include(min_one_max_one_dimacs)
+        end
+      end
+
+      context "min_on: 2, max_on: 2" do
+        it "produces correct clauses" do
+          group = SwitchGroup.new(min_on: 2, max_on: 2) { true }
+          expect(group.dimacs).to include(min_two_max_two_dimacs)
+        end
+      end
+
+      context "min_on: 0, max_on: 2" do
+        it "produces correct clauses" do
+          group = SwitchGroup.new(min_on: 0, max_on: 2) { true }
+          expect(group.dimacs).to include(min_zero_max_two_dimacs)
+        end
+      end
+
+      context "min_on: 1, max_on: 2" do
+        it "produces correct clauses" do
+          group = SwitchGroup.new(max_on: 2) { true }
+          expect(group.dimacs).to include(min_one_max_two_dimacs)
+        end
+      end
+    end
+  end
+end

data/spec/lib/whatnot/switch_interpreter_spec.rb

@@ -0,0 +1,188 @@
+require 'spec_helper'
+
+def print_sudoku(solution)
+  puts "+-------+-------+-------+"
+  ("A".."C").to_a.each do |letter|
+    print "| "
+    print solution.fetch(:"#{letter}1", " ").to_s + " "
+    print solution.fetch(:"#{letter}2", " ").to_s + " "
+    print solution.fetch(:"#{letter}3", " ").to_s
+    print " | "
+    print solution.fetch(:"#{letter}4", " ").to_s + " "
+    print solution.fetch(:"#{letter}5", " ").to_s + " "
+    print solution.fetch(:"#{letter}6", " ").to_s
+    print " | "
+    print solution.fetch(:"#{letter}7", " ").to_s + " "
+    print solution.fetch(:"#{letter}8", " ").to_s + " "
+    print solution.fetch(:"#{letter}9", " ").to_s
+    print " |\n"
+  end
+  puts "+-------+-------+-------+"
+  ("D".."F").to_a.each do |letter|
+    print "| "
+    print solution.fetch(:"#{letter}1", " ").to_s + " "
+    print solution.fetch(:"#{letter}2", " ").to_s + " "
+    print solution.fetch(:"#{letter}3", " ").to_s
+    print " | "
+    print solution.fetch(:"#{letter}4", " ").to_s + " "
+    print solution.fetch(:"#{letter}5", " ").to_s + " "
+    print solution.fetch(:"#{letter}6", " ").to_s
+    print " | "
+    print solution.fetch(:"#{letter}7", " ").to_s + " "
+    print solution.fetch(:"#{letter}8", " ").to_s + " "
+    print solution.fetch(:"#{letter}9", " ").to_s
+    print " |\n"
+  end
+  puts "+-------+-------+-------+"
+  ("G".."I").to_a.each do |letter|
+    print "| "
+    print solution.fetch(:"#{letter}1", " ").to_s + " "
+    print solution.fetch(:"#{letter}2", " ").to_s + " "
+    print solution.fetch(:"#{letter}3", " ").to_s
+    print " | "
+    print solution.fetch(:"#{letter}4", " ").to_s + " "
+    print solution.fetch(:"#{letter}5", " ").to_s + " "
+    print solution.fetch(:"#{letter}6", " ").to_s
+    print " | "
+    print solution.fetch(:"#{letter}7", " ").to_s + " "
+    print solution.fetch(:"#{letter}8", " ").to_s + " "
+    print solution.fetch(:"#{letter}9", " ").to_s
+    print " |\n"
+  end
+  puts "+-------+-------+-------+"
+end
+
+module Whatnot
+  describe SwitchInterpreter do
+    describe "full usage" do
+      context "simplest with set, slot, & constraint" do
+        let(:expected) do
+          [{:B=>2}, {:B=>1}, {:A=>[3], :B=>1}, {:A=>[5], :B=>1}, {:A=>[4], :B=>1}, {:A=>[3, 4], :B=>1}, {:A=>[4, 5], :B=>1}, {:A=>[3, 5], :B=>1}]
+        end
+
+        it "works" do
+          i = SwitchInterpreter.new
+          i.create_set(:A, [3,4,5], allow_empty: true, max_values: 2)
+          i.create_slot(:B, [1,2], allow_empty: false)
+          i.create_constraint(:A, :B) do |**sol| sol[:A].nil? || sol[:B] == 1; end
+
+          solutions = SolutionEnumerator.new(i.method(:interpret), i.dimacs).entries
+          expect(solutions).to eq(expected)
+        end
+      end
+
+      context "mutually exclusive sets" do
+        let(:expected) do
+          [{:B=>[3, 4, 5]},
+           {:A=>[3], :B=>[4, 5]},
+           {:A=>[4], :B=>[3, 5]},
+           {:A=>[3, 4, 5]},
+           {:A=>[5], :B=>[3, 4]},
+           {:A=>[3, 4], :B=>[5]},
+           {:A=>[3, 5], :B=>[4]},
+           {:A=>[4, 5], :B=>[3]}]
+        end
+
+        it "works" do
+          i = SwitchInterpreter.new
+          i.create_mutually_exclusive_sets([:A, :B], [3,4,5], allow_empty: true, max_values: 3)
+
+          solutions = SolutionEnumerator.new(i.method(:interpret), i.dimacs).entries
+          expect(solutions).to eq(expected)
+        end
+      end
+    end
+
+    describe "sudoku" do
+      it "works" do
+        puts "\nSudoku: "
+
+        puzzle = {
+          :A1 => 8,
+          :C2 => 3,
+          :D2 => 6,
+          :B3 => 7,
+          :E3 => 9,
+          :G3 => 2,
+          :B4 => 5,
+          :F4 => 7,
+          :E5 => 4,
+          :F5 => 5,
+          :G5 => 7,
+          :D6 => 1,
+          :H6 => 3,
+          :C7 => 1,
+          :H7 => 6,
+          :I7 => 8,
+          :C8 => 8,
+          :D8 => 5,
+          :H8 => 1,
+          :B9 => 9,
+          :G9 => 4
+        }
+
+        print_sudoku(puzzle)
+
+        i = SwitchInterpreter.new
+
+        ("A".."I").to_a.each do |letter|
+          ('1'..'9').to_a.each do |num|
+            i.create_slot(:"#{letter}#{num}", [1,2,3,4,5,6,7,8,9], allow_empty: false)
+          end
+        end
+
+        (1..9).to_a.each do |slotnum|
+          slots_for_column = ("A".."I").to_a.map { |letter| :"#{letter}#{slotnum}" }
+
+          slots_for_column.combination(2) do |slot1, slot2|
+            i.create_constraint(slot1, slot2) do |**solution|
+              solution[slot1] != solution[slot2]
+            end
+          end
+        end
+
+        ("A".."I").to_a.map(&:to_sym).each do |slotletter|
+          slots_for_row = ('1'..'9').to_a.map { |num| :"#{slotletter}#{num}" }
+
+          slots_for_row.combination(2) do |slot1, slot2|
+            i.create_constraint(slot1, slot2) do |**solution|
+              solution[slot1] != solution[slot2]
+            end
+          end
+        end
+
+        squares = [
+          ["A1","A2","A3","B1","B2","B3","C1","C2","C3"],
+          ["A4","A5","A6","B4","B5","B6","C4","C5","C6"],
+          ["A7","A8","A9","B7","B8","B9","C7","C8","C9"],
+          ["D1","D2","D3","E1","E2","E3","F1","F2","F3"],
+          ["D4","D5","D6","E4","E5","E6","F4","F5","F6"],
+          ["D7","D8","D9","E7","E8","E9","F7","F8","F9"],
+          ["G1","G2","G3","H1","H2","H3","I1","I2","I3"],
+          ["G4","G5","G6","H4","H5","H6","I4","I5","I6"],
+          ["G7","G8","G9","H7","H8","H9","I7","I8","I9"]
+        ]
+
+        squares.each do |square|
+          slots_for_square = square.map(&:to_sym)
+
+          slots_for_square.combination(2) do |slot1, slot2|
+            i.create_constraint(slot1, slot2) do |**solution|
+              solution[slot1] != solution[slot2]
+            end
+          end
+        end
+
+        puzzle.each do |slot, val|
+          i.create_constraint(slot) { |**sol| sol[slot] == val }
+        end
+
+        solution = SolutionEnumerator.new(i.method(:interpret), i.dimacs).first
+
+        print_sudoku(solution)
+
+        puts
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,89 @@
+require(File.expand_path("../../lib/whatnot.rb", __FILE__))
+
+# This file was generated by the `rails generate rspec:install` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end