dancing-links 0.1 → 0.1.0.1

data/README.rdoc

@@ -0,0 +1,46 @@
+This module provides an implementation of the "dancing links" algorhthm
+to solve the "exact cover" problem.
+
+The "exact cover" problem:
+- Given a set of vectors containing 0's and 1's:
+- Find a subset of these vectors that collectively contain one and only one 1 in each and every column.
+
+For example the follwing set of vectors:
+- A = [ 0, 1, 0]
+- B = [ 1, 1, 0]
+- C = [ 1, 0, 0]
+- D = [ 0, 0, 1]
+
+Has two solutions:
+- A = [ 0, 1, 0]
+- C = [ 1, 0, 0]
+- D = [ 0, 0, 1]
+
+and
+- B = [ 1, 1, 0]
+- D = [ 0, 0, 1]
+
+A better description of the problem can be found here:
+http://en.wikipedia.org/wiki/Exact_cover
+
+The "dancing links" algorithm is a commonly used solution for this problem and
+was found by Donald Knuth.  The algorithm involves the construction of a
+sparse matrix containing nodes that are doubly-linked both horizontally and
+vertically.  The matrix itself simply facilitates the depth-first search
+(aka backtracking) part of the algorithm.
+
+The importance of the doubly-linked nodes are that they allow for quick
+removal/restoration of rows/columns of nodes, which is exactly what a
+backtracking algorithm for the "exact cover" problem needs.
+
+horizontal removal:
+- node.left.right = node.right
+- node.right.left = node.left
+
+horizontal restoration:
+- node.left.right = node
+- node.right.left = node
+
+A better description of the algorithm can be found here:
+http://en.wikipedia.org/wiki/Dancing_Links
+

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rdoc/task'
+
+task :default => [:rdoc, :gem]
+
+PKG_FILES = FileList['lib/**/*.rb','[A-Z]*']
+
+gem_spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'An implementation of "Dancing Links".'
+  s.name = "dancing-links"
+  s.version = "0.1.0.1"
+  s.authors = ["Justin W Smith"]
+  s.require_path = 'lib'
+  s.email = 'justin dot w dot smith @t gmail.com'
+  s.files = PKG_FILES
+  s.homepage = 'https://rubygems.org/gems/dancing-links'
+  s.has_rdoc = true
+  s.rubyforge_project = 'sudoku-gtk'
+  s.description = 'An implementation of the "dancing links" algorithm to solve the "exact cover" problem.'
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end
+
+
+Gem::PackageTask.new(gem_spec) do |t|
+  t.need_zip = true
+  t.need_tar = true
+end
+

data/lib/dancing_links.rb

@@ -19,56 +19,6 @@
 # SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 
-=begin rdoc
-
-This module provides an implementation of the "dancing links" algorhthm
-to solve the "exact cover" problem.
-
-The "exact cover" problem:
-- Given a set of vectors containing 0's and 1's:
-- Find a subset of these vectors that collectively contain one and only one 1 in each and every column.
-
-For example the follwing set of vectors:
-- A = [ 0, 1, 0]
-- B = [ 1, 1, 0]
-- C = [ 1, 0, 0]
-- D = [ 0, 0, 1]
-
-Has two solutions:
-- A = [ 0, 1, 0]
-- C = [ 1, 0, 0]
-- D = [ 0, 0, 1]
-
-and
-- B = [ 1, 1, 0]
-- D = [ 0, 0, 1]
-
-A better description of the problem can be found here:
-http://en.wikipedia.org/wiki/Exact_cover
-
-The "dancing links" algorithm is a commonly used solution for this problem, and
-was found by Donald Knuth.  The algorithm involves the construction of a
-sparse matrix containing nodes that are doubly-linked both horizontally and
-vertically.  The matrix itself simply facilitates the depth-first search
-(aka backtracking) part of the algorithm.
-
-The importance of the doubly-linked nodes are that they allow for quick
-removal/restoration of rows/columns of nodes, which is exactly what a
-backtracking algorithm for the "exact cover" problem needs.
-
-horizontal removal:
-- node.left.right = node.right
-- node.right.left = node.left
-
-horizontal restoration:
-- node.left.right = node
-- node.right.left = node
-
-A better description of the algorithm can be found here:
-http://en.wikipedia.org/wiki/Dancing_Links
-
-=end
-
 module DancingLinks
 
 private

metadata

@@ -1,39 +1,48 @@
---- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.10
-specification_version: 1
+--- !ruby/object:Gem::Specification
 name: dancing-links
-version: !ruby/object:Gem::Version 
-  version: "0.1"
-date: 2006-01-28
-summary: Implementation of the "Dancing Links" algorithm.
-require_paths: 
-  - lib
-email: justin dot w dot smith at gmail dot com
-homepage: http://rubyforge.org/projects/sudoku-gtk/
-rubyforge_project: 
-description: Dancing-links is an implementation of the "Dancing Links" algorthm to solve the "Exact Cover" problem.  Algorithm found by Donald Knuth.
-autorequire: dancing_links
-default_executable: 
-bindir: bin
-has_rdoc: true
-required_ruby_version: !ruby/object:Gem::Version::Requirement 
-  requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
-  version: 
+version: !ruby/object:Gem::Version
+  version: 0.1.0.1
+  prerelease: 
 platform: ruby
-authors: []
-files: 
-  - lib/dancing_links.rb
-  - lib/array_combs_perms.rb
-test_files: 
-  - test/tc_dancing_links.rb
-rdoc_options: []
-extra_rdoc_files: []
+authors:
+- Justin W Smith
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-27 00:00:00.000000000 Z
+dependencies: []
+description: An implementation of the "dancing links" algorithm to solve the "exact
+  cover" problem.
+email: justin dot w dot smith @t gmail.com
 executables: []
 extensions: []
-requirements: 
-  - none
-dependencies: []
+extra_rdoc_files: []
+files:
+- lib/dancing_links.rb
+- Rakefile
+- README.rdoc
+homepage: https://rubygems.org/gems/dancing-links
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: sudoku-gtk
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: An implementation of "Dancing Links".
+test_files: []

data/lib/array_combs_perms.rb

@@ -1,59 +0,0 @@
-
-# Copyright (c) 2006 Justin W Smith
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this
-# software and associated documentation files (the "Software"), to deal in the Software
-# without restriction, including without limitation the rights to use, copy, modify,
-# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to the following
-# conditions:
-
-# The above copyright notice and this permission notice shall be included in all copies
-# or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-class Array
-  def to_s
-    s = "["
-    each_index do |i|
-      s << " " + self[i].to_s
-      s << ", " unless (i == self.length-1)
-    end
-    s << "]"
-  end
-  
-  def comb_helper head, tail, &block
-    if tail.length == 0
-      block.call(head)
-    else
-      tail.each_index do |i|
-        t = tail.clone
-        t.delete_at(i)
-        comb_helper head.clone << tail[i], t, &block
-      end
-    end
-  end
-
-  def combinations &block
-    comb_helper [], self, &block
-  end
-
-  def permutations &block
-    perm_helper [self[0]], self[1...self.length], &block
-  end
-  
-  def perm_helper head, tail, &block
-    block.call(head)
-    t = tail.clone
-    until t.empty?
-      val = t.pop
-      comb_helper head.clone << val, t, &block
-    end
-  end
-end

data/test/tc_dancing_links.rb

@@ -1,222 +0,0 @@
-
-# Copyright (c) 2006 Justin W Smith
-
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this
-# software and associated documentation files (the "Software"), to deal in the Software
-# without restriction, including without limitation the rights to use, copy, modify,
-# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to the following
-# conditions:
-
-# The above copyright notice and this permission notice shall be included in all copies
-# or substantial portions of the Software.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-# PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
-# HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-# SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
-
-require 'test/unit'
-require 'lib/dancing_links'
-
-class Array
-  def to_s
-    s = "["
-    each_index do |i|
-      s << " " + self[i].to_s
-      s << ", " unless (i == self.length-1)
-    end
-    s << "]"
-  end
-  
-  def comb_helper head, tail, &block
-    if tail.length == 0
-      block.call(head)
-    else
-      tail.each_index do |i|
-        t = tail.clone
-        t.delete_at(i)
-        comb_helper head.clone << tail[i], t, &block
-      end
-    end
-  end
-
-  def combinations &block
-    comb_helper [], self, &block
-  end
-end
-
-class TC_DancingLinks < Test::Unit::TestCase
-  include DancingLinks
-  
-  def setup
-    @a1 = [ [1, 0, 1], [0, 0, 1], [1, 1, 0], [ 1, 0, 0] ]
-    @b1 = [ [ true, false, true],
-            [false, false, true],
-            [true, true, false],
-            [true, false, false] ]
-    @matrix1 = SparseMatrix.new convert_rows_fixnum_to_boolean(@a1)
-    @s1 = [ [ 0, 0, 1], [ 1, 1, 0] ]
-
-    @a2 = [ [1, 0, 1], [1, 1, 0], [0, 1, 1], [ 0, 0, 0] ]
-    @e2 = [ [0, 0, 1] ]
-    @matrix2 = SparseMatrix.new convert_rows_fixnum_to_boolean(@a2)
-    @s2 = [ [0, 0, 1], [ 1, 1, 0] ]
-
-    @a3 = [ [1, 0, 1], [1, 1, 0], [0, 1, 1], [ 1, 1, 1] ]
-    @matrix3 = SparseMatrix.new convert_rows_fixnum_to_boolean(@a3)
-    @s3 = [[1, 1, 1]]
-
-    @a4 = [ [1, 0, 1], [1, 1, 0], [0, 1, 1], [ 0, 1, 0] ]
-    @matrix4 = SparseMatrix.new convert_rows_fixnum_to_boolean(@a4)
-    @s4 = [[1, 0, 1], [0, 1, 0]]
-
-    @a5 = [ [1, 0, 1], [1, 1, 0], [1, 1, 1], [ 0, 1, 1] ]
-    @matrix5 = SparseMatrix.new convert_rows_fixnum_to_boolean(@a4)
-    @s5 = [[1, 1, 1]]
-
-    @a6 = [ [1, 0, 1], [1, 0, 0], [1, 1, 1], [ 0, 1, 1], [1, 1, 0] ]
-
-    @a7 = [ [0, 0, 1], [ 0, 1, 0], [0, 1, 1], [1, 0, 0], [1, 0, 1], [1, 1, 0], [1, 1, 1] ]
-    @s7 = [
-            [ [ 1, 1, 1] ],
-            [ [ 0, 1, 1], [ 1, 0, 0 ] ].sort,
-            [ [ 1, 0, 1], [ 0, 1, 0 ] ].sort,
-            [ [ 1, 1, 0], [ 0, 0, 1] ].sort,
-            [ [ 0, 0, 1], [0, 1, 0], [1, 0, 0] ].sort ]
-  end
-  
-  def test_convert_rows
-    assert_equal(@a1, convert_rows_boolean_to_fixnum(@b1) )
-    assert_equal(@b1, convert_rows_fixnum_to_boolean(@a1) )
-  end
-  
-  def test_sparse_matrix
-    root = @matrix1.root
-    assert_equal(3, root.count)
-    assert_equal(3, root.right.count)
-    assert_equal(1, root.right.right.count)
-    assert_equal(2, root.right.right.right.count)
-    assert_equal(root.right.up.left, root.right.up)
-    assert_equal(root.left.up.left, root.right.right.right.down.down)
-    assert_equal(root.right.down.header, root.right)
-    assert_equal(root.left.up.header, root.left)
-    assert_equal(root.right.right.right.right, root)
-    assert_equal(root.left.left.left.left, root)
-    
-    assert_equal(0, root.left.down.row_num)
-    assert_equal(1, root.left.down.down.row_num)
-    assert_equal(2, root.right.right.down.row_num)
-    assert_equal(3, root.right.up.row_num)
-        
-    assert_equal(0, root.right.index)
-    assert_equal(3, root.right.count)
-    assert_equal(1, root.right.right.index)
-    assert_equal(1, root.right.right.count)
-    assert_equal(2, root.right.right.right.index)
-    assert_equal(2, root.right.right.right.count)
-    
-  end
-
-  def test_remove_rows_for_header
-    root = @matrix1.root
-    remove_rows_for_header root.right
-    assert_equal( 0,  root.right.count)
-    assert_equal( 0,  root.right.right.count)
-    assert_equal( 1,  root.right.right.right.count)
-    assert_equal( root.right.right.right,  root.left)
-    assert_equal( root.left.down,  root.right.right.right.up)
-    assert_equal( 1, root.left.down.row_num)
-  end
-  
-  def test_restore_rows_for_header
-    root = @matrix1.root
-    restore_rows_for_header( remove_rows_for_header( root.right))
-    test_sparse_matrix
-  end
-
-  def test_select_row
-    root = @matrix1.root
-    header_stk, row_stk_stk = select_row root.right.right.down
-
-    assert_equal( 1, root.count)
-    assert_equal( 1, root.right.count)
-    assert_equal( 2, root.right.index )
-    assert_equal( root.right.down, root.left.down)
-    assert_equal( root.right.down.down, root.left)
-    assert_equal( root.right.down.down, root.left)
-
-  end
-
-  def test_restore_selected_row
-
-    root = @matrix1.root
-    restore_selected_row( *select_row( root.right.right.down))
-    test_sparse_matrix
-    restore_selected_row( *select_row( root.right.down))
-    test_sparse_matrix
-    restore_selected_row( *select_row( root.left.down))
-    test_sparse_matrix
-    restore_selected_row( *select_row( root.left.up))
-    test_sparse_matrix
-    restore_selected_row( *select_row( root.right.up))
-    test_sparse_matrix
-    restore_selected_row( *select_row( root.left.up))
-    test_sparse_matrix
-
-    header_stk, row_stk_stk = select_row( root.right.right.down)
-    restore_selected_row( *select_row( root.right.down) )
-    restore_selected_row( header_stk, row_stk_stk)
-    test_sparse_matrix
-
-  end
-
-  def test_min_column
-    root = @matrix1.root
-    header = min_column root
-    assert_equal( root.right.right, header)
-  end
-
-  def test_solve_exact_cover
-    s = convert_rows_boolean_to_fixnum(solve_exact_cover( @b1))
-    assert_equal(@s1.sort, s.sort)
-
-    s = solve_exact_cover( convert_rows_fixnum_to_boolean(@a2))
-    assert_equal(0, s)
-
-    s = convert_rows_boolean_to_fixnum(solve_exact_cover( convert_rows_fixnum_to_boolean(@a2), convert_rows_fixnum_to_boolean(@e2)))
-    assert_equal(@s2.sort, s.sort)
-
-    s = convert_rows_boolean_to_fixnum(solve_exact_cover( convert_rows_fixnum_to_boolean(@a3)))
-    assert_equal(@s3.sort, s.sort)
-
-    s = convert_rows_boolean_to_fixnum(solve_exact_cover( convert_rows_fixnum_to_boolean(@a4)))
-    assert_equal(@s4.sort, s.sort)
-
-    s = convert_rows_boolean_to_fixnum(solve_exact_cover( convert_rows_fixnum_to_boolean(@a5)))
-    assert_equal(@s5.sort, s.sort)
-
-    s = solve_exact_cover( convert_rows_fixnum_to_boolean(@a6)){false}
-    assert_equal(2, s)
-
-  end
-  
-  def test_solve_exact_cover2
-
-    @a7.combinations do |comb|
-      s = @s7.clone
-      solve_exact_cover(convert_rows_fixnum_to_boolean(comb)) do |result|
-        result = convert_rows_boolean_to_fixnum( result ).sort!
-        assert( s.member?( result ), "\ncomb: #{comb.to_s}\nresult: #{result}\nsolutions left: #{s.to_s}")
-        s.delete result
-        false
-      end
-      assert_equal( [], s)
-    end
-    
-  end
-
-end