permutation 0.1.3 → 0.1.4

data/CHANGES

@@ -1,3 +1,7 @@
+2006-03-11 (0.1.4)
+    * Applied two bugfixes. Thanks go to Roel Harbers <roel@roelharbers.com>
+      for the report.
+    * Disabled autorequire for gem.
 2004-07-16 (0.1.3)
     * Moved gemspec into Rakefile
     * Cleaned up a bit.

data/Rakefile

@@ -5,9 +5,7 @@ include Config
 
 PKG_NAME = 'permutation'
 PKG_VERSION = File.read('VERSION').chomp
-PKG_FILES = Dir.glob("**/*").delete_if { |item|
-  item.include?("CVS") or item.include?("pkg")
-}
+PKG_FILES = FileList["**/*"].exclude(/(CVS|pkg|doc)/)
 
 desc "Installing library"
 task :install  do
@@ -31,7 +29,7 @@ spec = Gem::Specification.new do |s|
   s.name = 'permutation'
   s.version = PKG_VERSION
   s.summary = 'Permutation library in pure Ruby'
-  s.description = ""
+  s.description = "Library to perform different operations with permutations of sequences (strings, arrays, etc.)"
 
   #### Dependencies and requirements.
 
@@ -47,7 +45,7 @@ spec = Gem::Specification.new do |s|
   #### Load-time details: library and application (you will need one or both).
 
   s.require_path = 'lib'                         # Use these for libraries.
-  s.autorequire = 'permutation'
+  #s.autorequire = 'permutation'
 
   #s.bindir = "bin"                              # Use these for applications.
   #s.executables = ["bla.rb"]
@@ -75,4 +73,6 @@ Rake::GemPackageTask.new(spec) do |pkg|
   pkg.need_tar = true
   pkg.package_files += PKG_FILES
 end
+
+task :release => :package
   # vim: set et sw=2 ts=2:

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/lib/permutation.rb

@@ -184,10 +184,7 @@ class Permutation
     # Permutation#value method of this instance is the permutation ranked with
     # this new <code>rank</code>.
     def rank=(m)
-        last = factorial(size) - 1
-        while m > last do m -= last end
-        while m < 0 do m += last end
-        @rank = m
+      @rank = m % factorial(size) 
     end
 
     # Returns the indices in the range of 0    to Permutation#size - 1
@@ -262,7 +259,7 @@ class Permutation
     # Switches this Permutation instance to random permutation
     # of size Permutation#size.
     def random!
-        new_rank = rand(last).to_i
+        new_rank = rand(last + 1).to_i
         self.rank = new_rank
         self
     end

data/test/test.rb

@@ -4,244 +4,250 @@ require 'test/unit'
 require 'permutation'
 
 class TC_Permutation < Test::Unit::TestCase
-
-    def setup
-        @perms = (0..4).map { |i| Permutation.new(i) }
-        @perms_collections = [ "", "a", "ab", "abc", "abcd" ].map do |c|
-            Permutation.for(c)
-        end
-        @perms_each = [
-            [[]],
-            [[0]],
-            [[0, 1], [1, 0]],
-            [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]],
-            [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1],
-                [0, 3, 1, 2], [0, 3, 2, 1], [1, 0, 2, 3], [1, 0, 3, 2],
-                [1, 2, 0, 3], [1, 2, 3, 0], [1, 3, 0, 2], [1, 3, 2, 0],
-                [2, 0, 1, 3], [2, 0, 3, 1], [2, 1, 0, 3], [2, 1, 3, 0],
-                [2, 3, 0, 1], [2, 3, 1, 0], [3, 0, 1, 2], [3, 0, 2, 1],
-                [3, 1, 0, 2], [3, 1, 2, 0], [3, 2, 0, 1], [3, 2, 1, 0]]
-        ]
-        @next_pred = [
-            [ [], [] ],
-            [ [ 0 ], [ 0 ] ],
-            [ [ 0, 1 ], [ 1, 0 ] ],
-            [ [ 1, 0 ], [ 0, 1 ] ],
-            [ [ 0, 1, 2 ], [ 0, 2, 1 ] ],
-            [ [ 0, 2, 1 ], [ 1, 0, 2 ] ],
-            [ [ 1, 0, 2 ], [ 1, 2, 0 ] ],
-            [ [ 1, 2, 0 ], [ 2, 0, 1 ] ],
-            [ [ 2, 0, 1 ], [ 2, 1, 0 ] ],
-            [ [ 2, 1, 0 ], [ 0, 1, 2 ] ],
-        ]
-        @projected = [
-            [ "" ],
-            [ "a" ],
-            [ "ab", "ba", ],
-            [ "abc", "acb", "bac", "bca", "cab", "cba" ],
-            [ "abcd", "abdc", "acbd", "acdb", "adbc", "adcb", "bacd",
-                "badc", "bcad", "bcda", "bdac", "bdca", "cabd", "cadb",
-                "cbad", "cbda", "cdab", "cdba", "dabc", "dacb", "dbac",
-                "dbca", "dcab", "dcba"]
-        ]
-        @products = [
-            {[0, 0]=>[]},
-            {[0, 0]=>[0]},
-            {[0, 0]=>[0, 1], [1, 1]=>[0, 1], [1, 0]=>[1, 0], [0, 1]=>[1, 0]},
-            {[2, 4]=>[2, 1, 0], [1, 2]=>[2, 0, 1], [0, 0]=>[0, 1, 2],
-                    [5, 4]=>[0, 2, 1], [3, 3]=>[2, 0, 1], [2, 1]=>[1, 2, 0],
-                    [0, 5]=>[2, 1, 0], [3, 5]=>[0, 2, 1], [1, 1]=>[0, 1, 2],
-                    [0, 3]=>[1, 2, 0], [5, 3]=>[1, 0, 2], [4, 1]=>[2, 1, 0],
-                    [3, 2]=>[2, 1, 0], [2, 0]=>[1, 0, 2], [0, 4]=>[2, 0, 1],
-                    [3, 4]=>[0, 1, 2], [1, 0]=>[0, 2, 1], [0, 2]=>[1, 0, 2],
-                    [5, 2]=>[1, 2, 0], [4, 0]=>[2, 0, 1], [3, 1]=>[1, 0, 2],
-                    [2, 3]=>[0, 2, 1], [1, 5]=>[1, 2, 0], [4, 5]=>[1, 0, 2],
-                    [5, 1]=>[2, 0, 1], [4, 3]=>[0, 1, 2], [3, 0]=>[1, 2, 0],
-                    [2, 2]=>[0, 1, 2], [1, 4]=>[1, 0, 2], [4, 4]=>[1, 2, 0],
-                    [5, 0]=>[2, 1, 0], [4, 2]=>[0, 2, 1], [2, 5]=>[2, 0, 1],
-                    [1, 3]=>[2, 1, 0], [0, 1]=>[0, 2, 1], [5, 5]=>[0, 1, 2]}
-        ]
-        @cycles = [
-            [[]],
-            [[]],
-            [[], [[0, 1]]],
-            [[], [[1, 2]], [[0, 1]], [[0, 1, 2]], [[0, 2, 1]], [[0, 2]]],
-            [[], [[2, 3]], [[1, 2]], [[1, 2, 3]], [[1, 3, 2]], [[1, 3]],
-                [[0, 1]], [[0, 1], [2, 3]], [[0, 1, 2]], [[0, 1, 2, 3]],
-                [[0, 1, 3, 2]], [[0, 1, 3]], [[0, 2, 1]], [[0, 2, 3, 1]],
-                [[0, 2]], [[0, 2, 3]], [[0, 2], [1, 3]], [[0, 2, 1, 3]],
-                [[0, 3, 2, 1]], [[0, 3, 1]], [[0, 3, 2]], [[0, 3]],
-                [[0, 3, 1, 2]], [[0, 3], [1, 2]]]
-        ]
-        @signum = [
-            [1],
-            [1],
-            [1, -1],
-            [1, -1, -1, 1, 1, -1],
-            [1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1,
-                -1, 1, 1, -1, -1, 1]
-        ]
+  def setup
+    @perms = (0..4).map { |i| Permutation.new(i) }
+    @perms_collections = [ "", "a", "ab", "abc", "abcd" ].map do |c|
+      Permutation.for(c)
     end
+    @perms_each = [
+      [[]],
+      [[0]],
+      [[0, 1], [1, 0]],
+      [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1], [2, 1, 0]],
+      [[0, 1, 2, 3], [0, 1, 3, 2], [0, 2, 1, 3], [0, 2, 3, 1],
+        [0, 3, 1, 2], [0, 3, 2, 1], [1, 0, 2, 3], [1, 0, 3, 2],
+        [1, 2, 0, 3], [1, 2, 3, 0], [1, 3, 0, 2], [1, 3, 2, 0],
+        [2, 0, 1, 3], [2, 0, 3, 1], [2, 1, 0, 3], [2, 1, 3, 0],
+        [2, 3, 0, 1], [2, 3, 1, 0], [3, 0, 1, 2], [3, 0, 2, 1],
+        [3, 1, 0, 2], [3, 1, 2, 0], [3, 2, 0, 1], [3, 2, 1, 0]]
+    ]
+    @next_pred = [
+      [ [], [] ],
+      [ [ 0 ], [ 0 ] ],
+      [ [ 0, 1 ], [ 1, 0 ] ],
+      [ [ 1, 0 ], [ 0, 1 ] ],
+      [ [ 0, 1, 2 ], [ 0, 2, 1 ] ],
+      [ [ 0, 2, 1 ], [ 1, 0, 2 ] ],
+      [ [ 1, 0, 2 ], [ 1, 2, 0 ] ],
+      [ [ 1, 2, 0 ], [ 2, 0, 1 ] ],
+      [ [ 2, 0, 1 ], [ 2, 1, 0 ] ],
+      [ [ 2, 1, 0 ], [ 0, 1, 2 ] ],
+    ]
+    @projected = [
+      [ "" ],
+      [ "a" ],
+      [ "ab", "ba", ],
+      [ "abc", "acb", "bac", "bca", "cab", "cba" ],
+      [ "abcd", "abdc", "acbd", "acdb", "adbc", "adcb", "bacd",
+        "badc", "bcad", "bcda", "bdac", "bdca", "cabd", "cadb",
+        "cbad", "cbda", "cdab", "cdba", "dabc", "dacb", "dbac",
+        "dbca", "dcab", "dcba"]
+    ]
+    @products = [
+      {[0, 0]=>[]},
+      {[0, 0]=>[0]},
+      {[0, 0]=>[0, 1], [1, 1]=>[0, 1], [1, 0]=>[1, 0], [0, 1]=>[1, 0]},
+      {[2, 4]=>[2, 1, 0], [1, 2]=>[2, 0, 1], [0, 0]=>[0, 1, 2],
+        [5, 4]=>[0, 2, 1], [3, 3]=>[2, 0, 1], [2, 1]=>[1, 2, 0],
+        [0, 5]=>[2, 1, 0], [3, 5]=>[0, 2, 1], [1, 1]=>[0, 1, 2],
+        [0, 3]=>[1, 2, 0], [5, 3]=>[1, 0, 2], [4, 1]=>[2, 1, 0],
+        [3, 2]=>[2, 1, 0], [2, 0]=>[1, 0, 2], [0, 4]=>[2, 0, 1],
+        [3, 4]=>[0, 1, 2], [1, 0]=>[0, 2, 1], [0, 2]=>[1, 0, 2],
+        [5, 2]=>[1, 2, 0], [4, 0]=>[2, 0, 1], [3, 1]=>[1, 0, 2],
+        [2, 3]=>[0, 2, 1], [1, 5]=>[1, 2, 0], [4, 5]=>[1, 0, 2],
+        [5, 1]=>[2, 0, 1], [4, 3]=>[0, 1, 2], [3, 0]=>[1, 2, 0],
+        [2, 2]=>[0, 1, 2], [1, 4]=>[1, 0, 2], [4, 4]=>[1, 2, 0],
+        [5, 0]=>[2, 1, 0], [4, 2]=>[0, 2, 1], [2, 5]=>[2, 0, 1],
+        [1, 3]=>[2, 1, 0], [0, 1]=>[0, 2, 1], [5, 5]=>[0, 1, 2]}
+    ]
+    @cycles = [
+      [[]],
+      [[]],
+      [[], [[0, 1]]],
+      [[], [[1, 2]], [[0, 1]], [[0, 1, 2]], [[0, 2, 1]], [[0, 2]]],
+      [[], [[2, 3]], [[1, 2]], [[1, 2, 3]], [[1, 3, 2]], [[1, 3]],
+        [[0, 1]], [[0, 1], [2, 3]], [[0, 1, 2]], [[0, 1, 2, 3]],
+        [[0, 1, 3, 2]], [[0, 1, 3]], [[0, 2, 1]], [[0, 2, 3, 1]],
+        [[0, 2]], [[0, 2, 3]], [[0, 2], [1, 3]], [[0, 2, 1, 3]],
+        [[0, 3, 2, 1]], [[0, 3, 1]], [[0, 3, 2]], [[0, 3]],
+        [[0, 3, 1, 2]], [[0, 3], [1, 2]]]
+    ]
+    @signum = [
+      [1],
+      [1],
+      [1, -1],
+      [1, -1, -1, 1, 1, -1],
+      [1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1, -1, 1, 1, -1,
+        -1, 1, 1, -1, -1, 1]
+    ]
+  end
 
-    def test_created
-        factorial = 1
-        @perms.each_with_index do |p, i|
-            assert_equal(i, p.size)
-            assert_equal(factorial - 1, p.last)
-            factorial *= (i + 1)
-        end
+  def test_created
+    factorial = 1
+    @perms.each_with_index do |p, i|
+      assert_equal(i, p.size)
+      assert_equal(factorial - 1, p.last)
+      factorial *= (i + 1)
     end
+  end
 
-    def test_rank_assign
-        perm = Permutation.new(3)
-        perms = [[0, 1, 2], [0, 2, 1], [1, 0, 2], [1, 2, 0], [2, 0, 1],
-                [2, 1, 0]]
-        (-5...0).each do |i|
-            perm.rank = i
-            assert_equal(perms[i + 5], perm.value)
-        end
-        (-10...-5).each do |i|
-            perm.rank = i
-            assert_equal(perms[i + 10], perm.value)
-        end
-        (0..5).each do |i|
-            perm.rank = i
-            assert_equal(perms[i], perm.value)
-        end
-        (6..10).each do |i|
-            perm.rank = i
-            assert_equal(perms[i - 5], perm.value)
-        end
-        (11..15).each do |i|
-            perm.rank = i
-            assert_equal(perms[i - 10], perm.value)
-        end
+  def test_rank_assign
+    perm = Permutation.new(3)
+    perms = [
+      [0, 1, 2],
+      [0, 2, 1],
+      [1, 0, 2],
+      [1, 2, 0],
+      [2, 0, 1],
+      [2, 1, 0],
+      [0, 1, 2],
+    ]
+    (-12...-6).each do |i|
+      perm.rank = i
+      assert_equal(perms[i + 12], perm.value)
     end
-
-    def test_compare
-        perm1 = Permutation.new(3)
-        perm2 = Permutation.new(3)
-        perm3 = perm1.dup
-        perm4 = Permutation.new(3, 1)
-        assert(!perm1.equal?(perm2))
-        assert(perm1 == perm2)
-        assert(perm1.eql?(perm2))
-        assert_equal(0, perm1 <=> perm2)
-        assert_equal(perm1.hash, perm2.hash)
-        assert(!perm1.equal?(perm3))
-        assert(perm1 == perm3)
-        assert(perm1.eql?(perm3))
-        assert_equal(0, perm1 <=> perm3)
-        assert_equal(perm1.hash, perm3.hash)
-        assert(!perm1.equal?(perm4))
-        assert(perm1 != perm4)
-        assert(!perm1.eql?(perm4))
-        assert_equal(-1, perm1 <=> perm4)
-        assert_equal(1, perm4 <=> perm1)
-        assert(perm1 < perm4)
-        assert(perm4 > perm1)
-        assert(perm1.hash != perm4.hash)
-        perms = perm1.to_a
-        perms[1..-1].each_with_index do |p, i|
-            assert(p > perms[i])
-            assert_equal(1, p <=> perms[i])
-            assert(perms[i] < p)
-            assert_equal(-1, perms[i] <=> p)
-        end
+    (-6...0).each do |i|
+      perm.rank = i
+      assert_equal(perms[i + 6], perm.value)
+    end
+    (0..6).each do |i|
+      perm.rank = i
+      assert_equal(perms[i], perm.value)
+    end
+    (6..12).each do |i|
+      perm.rank = i
+      assert_equal(perms[i - 6], perm.value)
+    end
+    (12..17).each do |i|
+      perm.rank = i
+      assert_equal(perms[i - 12], perm.value)
     end
+  end
 
-    def test_random
-        @perms_each.each_with_index do |perms, i|
-            perm = Permutation.new(i)
-            24.times do
-                assert(perms.member?(perm.random.value))
-            end
-        end
+  def test_compare
+    perm1 = Permutation.new(3)
+    perm2 = Permutation.new(3)
+    perm3 = perm1.dup
+    perm4 = Permutation.new(3, 1)
+    assert(!perm1.equal?(perm2))
+    assert(perm1 == perm2)
+    assert(perm1.eql?(perm2))
+    assert_equal(0, perm1 <=> perm2)
+    assert_equal(perm1.hash, perm2.hash)
+    assert(!perm1.equal?(perm3))
+    assert(perm1 == perm3)
+    assert(perm1.eql?(perm3))
+    assert_equal(0, perm1 <=> perm3)
+    assert_equal(perm1.hash, perm3.hash)
+    assert(!perm1.equal?(perm4))
+    assert(perm1 != perm4)
+    assert(!perm1.eql?(perm4))
+    assert_equal(-1, perm1 <=> perm4)
+    assert_equal(1, perm4 <=> perm1)
+    assert(perm1 < perm4)
+    assert(perm4 > perm1)
+    assert(perm1.hash != perm4.hash)
+    perms = perm1.to_a
+    perms[1..-1].each_with_index do |p, i|
+      assert(p > perms[i])
+      assert_equal(1, p <=> perms[i])
+      assert(perms[i] < p)
+      assert_equal(-1, perms[i] <=> p)
     end
+  end
 
-    def test_enumerable
-        @perms.each_with_index do |perm, i|
-            assert_equal(@perms_each[i], perm.map { |x| x.value })
-        end
-        @perms.each_with_index do |perm, i|
-            ary = []
-            old_rank = perm.rank
-            perm.each! { |x| ary << x.value }
-            assert_equal(@perms_each[i], ary)
-            assert_equal(old_rank, perm.rank)
-        end
+  def test_random
+    @perms_each.each_with_index do |perms, i|
+      perm = Permutation.new(i)
+      until perms.empty?
+        deleted = perms.delete perm.random.value
+        deleted and assert true
+      end
     end
+  end
 
-    def test_next
-        @next_pred.each do |before, after|
-            beforep = Permutation.from_value(before)
-            afterp = Permutation.from_value(after)
-            assert_equal(afterp, beforep.next)
-            assert_equal(beforep, afterp.pred)
-            assert_equal(afterp, beforep.succ)
-        end
+  def test_enumerable
+    @perms.each_with_index do |perm, i|
+      assert_equal(@perms_each[i], perm.map { |x| x.value })
     end
+    @perms.each_with_index do |perm, i|
+      ary = []
+      old_rank = perm.rank
+      perm.each! { |x| ary << x.value }
+      assert_equal(@perms_each[i], ary)
+      assert_equal(old_rank, perm.rank)
+    end
+  end
 
-    def test_project
-        too_big = Array.new(10)
-        @perms.each_with_index do |perms, i|
-            assert_equal(@projected[i],
-                perms.map { |p| p.project(@projected[i][0]) })
-            assert_raises(ArgumentError) { perms.project }
-            assert_raises(ArgumentError) { perms.project(too_big) }
-        end
-        @perms_collections.each_with_index do |perms, i|
-            assert_equal(@projected[i], perms.map { |p| p.project })
-        end
+  def test_next
+    @next_pred.each do |before, after|
+      beforep = Permutation.from_value(before)
+      afterp = Permutation.from_value(after)
+      assert_equal(afterp, beforep.next)
+      assert_equal(beforep, afterp.pred)
+      assert_equal(afterp, beforep.succ)
     end
+  end
 
-    def test_compose
-        too_big = Permutation.new(10)
-        @perms[0..3].each do |perm|
-            elements = perm.to_a
-            for i in 0...elements.size
-                for j in 0...elements.size
-                    assert_equal(@products[perm.size][[i, j]],
-                        (elements[i].compose(elements[j])).value)
-                    assert_equal(@products[perm.size][[i, j]],
-                        (elements[i] * elements[j]).value)
-                end
-                assert_raises(ArgumentError) { elements[i] * too_big }
-                assert_raises(ArgumentError) { elements[i].compose(too_big) }
-            end
-        end
+  def test_project
+    too_big = Array.new(10)
+    @perms.each_with_index do |perms, i|
+      assert_equal(@projected[i],
+                   perms.map { |p| p.project(@projected[i][0]) })
+      assert_raises(ArgumentError) { perms.project }
+      assert_raises(ArgumentError) { perms.project(too_big) }
+    end
+    @perms_collections.each_with_index do |perms, i|
+      assert_equal(@projected[i], perms.map { |p| p.project })
     end
+  end
 
-    def test_invert
-        @perms.each do |perm|
-            id = perm
-            perm.each do |p|
-                assert_equal(id.value, (p * p.invert).value)
-                assert_equal(id, p * p.invert)
-                assert_equal(id.value, (p * -p).value)
-                assert_equal(id, p * -p)
-            end
-        end
+  def test_compose
+    too_big = Permutation.new(10)
+    @perms[0..3].each do |perm|
+      elements = perm.to_a
+      for i in 0...elements.size
+        for j in 0...elements.size
+          assert_equal(@products[perm.size][[i, j]],
+                       (elements[i].compose(elements[j])).value)
+          assert_equal(@products[perm.size][[i, j]],
+                       (elements[i] * elements[j]).value)
+        end
+        assert_raises(ArgumentError) { elements[i] * too_big }
+        assert_raises(ArgumentError) { elements[i].compose(too_big) }
+      end
     end
+  end
 
-    def test_cycles
-        @perms.each_with_index do |perm, i|
-            assert_equal(@cycles[i], perm.map { |p| p.cycles })
-            assert_equal(perm.to_a,
-                @cycles[i].map { |c| Permutation.from_cycles(c, i) })
-        end
+  def test_invert
+    @perms.each do |perm|
+      id = perm
+      perm.each do |p|
+        assert_equal(id.value, (p * p.invert).value)
+        assert_equal(id, p * p.invert)
+        assert_equal(id.value, (p * -p).value)
+        assert_equal(id, p * -p)
+      end
     end
+  end
 
-    def test_signum
-        @perms.each_with_index do |perm, i|
-            assert_equal(@signum[i], perm.map { |p| p.signum })
-            assert_equal(@signum[i], perm.map { |p| p.sgn })
-            assert_equal(@signum[i].map { |x| x == 1 },
-                perm.map { |p| p.even? })
-            assert_equal(@signum[i].map { |x| x == -1 },
-                perm.map { |p| p.odd? })
-        end
+  def test_cycles
+    @perms.each_with_index do |perm, i|
+      assert_equal(@cycles[i], perm.map { |p| p.cycles })
+      assert_equal(perm.to_a,
+                   @cycles[i].map { |c| Permutation.from_cycles(c, i) })
     end
+  end
 
+  def test_signum
+    @perms.each_with_index do |perm, i|
+      assert_equal(@signum[i], perm.map { |p| p.signum })
+      assert_equal(@signum[i], perm.map { |p| p.sgn })
+      assert_equal(@signum[i].map { |x| x == 1 },
+                   perm.map { |p| p.even? })
+      assert_equal(@signum[i].map { |x| x == -1 },
+                   perm.map { |p| p.odd? })
+    end
+  end
 end
-    # vim: set et sw=4 ts=4:
+# vim: set et sw=2 ts=2:

metadata

@@ -3,50 +3,54 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: permutation
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
-date: 2005-10-05 00:00:00 +02:00
+  version: 0.1.4
+date: 2006-03-11 00:00:00 +01:00
 summary: Permutation library in pure Ruby
 require_paths: 
-  - lib
+- lib
 email: flori@ping.de
 homepage: http://permutation.rubyforge.org
 rubyforge_project: permutation
-description: ''
-autorequire: permutation
+description: Library to perform different operations with permutations of sequences (strings, arrays, etc.)
+autorequire: 
 default_executable: 
 bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
 authors: 
-  - Florian Frank
+- Florian Frank
 files: 
-  - examples
-  - install.rb
-  - GPL
-  - test
-  - Rakefile
-  - VERSION
-  - CHANGES
-  - lib
-  - make_doc.rb
-  - README.en
-  - examples/tsp.rb
-  - test/test.rb
-  - lib/permutation.rb
+- examples
+- install.rb
+- GPL
+- test
+- Rakefile
+- VERSION
+- CHANGES
+- lib
+- README.en
+- examples/tsp.rb
+- test/test.rb
+- lib/permutation.rb
 test_files: 
-  - test/test.rb
+- test/test.rb
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: []
+
+dependencies: []
+

data/make_doc.rb

@@ -1,6 +0,0 @@
-#!/usr/bin/env ruby
-
-$outdir = 'doc/'
-puts "Creating documentation in '#$outdir'."
-system "rdoc -d -o #$outdir lib/permutation.rb"
-    # vim: set et sw=4 ts=4: