art-decomp 0.2.1 → 0.3.0

data/VERSION

@@ -1 +1 @@
-0.2.1
+0.3.0

data/bin/ad-validate

@@ -6,4 +6,8 @@ require 'backports/1.9' if RUBY_VERSION < '1.9'
 require_relative '../lib/art-decomp'
 
 $stdout.sync = true
-p Marshal.load(File.open ARGV.first).all? { |d| print '.'; d.valid? }
+
+ARGV.each do |file|
+  print file
+  puts Marshal.load(File.open file).all? { |d| print '.'; d.valid? }
+end

data/lib/art-decomp/blanket.rb

@@ -64,15 +64,9 @@ module ArtDecomp class Blanket
   end
 
   def seps
-    # FIXME: consider an algorithm with lesser complexity
-    seps = Set[]
-    singles = 0
-    @ints.pairs.each { |int1, int2| singles |= int1 ^ int2 }
-    singles.bits.pairs.each do |elem1, elem2|
-      sep = Sep[elem1, elem2]
-      seps << sep unless @ints.any? { |int| int & sep == sep }
-    end
-    seps
+    potential = @ints.inject(0, :|).bits.pairs.map { |a, b| Sep[a,b] }
+    not_separate = @ints.map{ |i| i.bits.pairs.map { |a, b| Sep[a,b] } }.flatten
+    (potential - not_separate).to_set
   end
 
   def size

data/lib/art-decomp/graph.rb

@@ -1,24 +1,25 @@
 module ArtDecomp class Graph
 
-  attr_reader :edges, :vertices
-
   def initialize blanket, seps
-    @vertices = blanket.ints.dup
-    @vertices.delete_if { |this| @vertices.any? { |other| other != this and other & this == this } }
-    relevant = Hash[@vertices.map { |v| [v, seps.select { |s| v&s != 0 and v&s != s }.to_set] }]
-    @edges = @vertices.pairs.select do |a, b|
-      (relevant[a] & relevant[b]).any? { |s| a&s != b&s }
-    end.map(&:to_set).to_set
+    vertices = blanket.ints.dup
+    vertices.delete_if { |this| vertices.any? { |other| other != this and other & this == this } }
+    @edges = Hash[vertices.map { |vertex| [vertex, Set[]] }]
+    relevant = Hash[vertices.map { |v| [v, seps.select { |s| v&s != 0 and v&s != s }.to_set] }]
+    vertices.pairs.each do |a, b|
+      if (relevant[a] & relevant[b]).any? { |s| a&s != b&s }
+        @edges[a] << b
+        @edges[b] << a
+      end
+    end
   end
 
   def adjacent *vertices
-    return Set[] if @edges.all? { |edge| (edge & vertices).empty? }
-    @edges.reject { |edge| (edge & vertices).empty? }.inject(:|) - vertices
+    vertices.map { |vertex| @edges[vertex] }.inject(:|) - vertices
   end
 
   def blanket_from_colouring
     colours = {}
-    @vertices.sort_by { |vert| [-degree(vert), vert] }.each do |vertex|
+    @edges.keys.sort_by { |vert| [-degree(vert), vert] }.each do |vertex|
       forbidden = adjacent(vertex).map { |vert| colours[vert] }.to_set
       # FIXME: consider selecting colours on the least-popular-first basis
       colour = :a
@@ -31,28 +32,32 @@ module ArtDecomp class Graph
   end
 
   def complete?
-    2 * @edges.size == @vertices.size * (@vertices.size - 1)
+    @edges.values.map(&:size).inject(:+) == @edges.size * (@edges.size - 1)
   end
 
   def degree vertex
-    @edges.count { |edge| edge.include? vertex }
+    @edges[vertex].size
+  end
+
+  def edges
+    @edges.map { |v, adjacents| adjacents.map { |adj| Set[v, adj] } }.flatten.to_set
   end
 
   def merge_by_edge_labels!
-    return self if @vertices.size == 1
-    pins = @vertices.size.log2_ceil
-    until @vertices.size.log2_ceil < pins
+    return self if @edges.size == 1
+    pins = @edges.size.log2_ceil
+    until @edges.size.log2_ceil < pins
       # FIXME: edge labels can/should be cached from previous computations
-      a, b = *@edges.sort_by { |edge| yield *edge }.first
+      a, b = *edges.sort_by { |edge| yield *edge }.first
       merge! a, b
     end
     self
   end
 
   def merge_by_vertex_degrees!
-    pins = @vertices.size.log2_ceil
-    until @vertices.size.log2_ceil < pins or complete?
-      a, b = *@vertices.sort_by { |v| -degree(v) }.pairs.find { |v1, v2| not @edges.include? Set[v1, v2] }
+    pins = @edges.size.log2_ceil
+    until @edges.size.log2_ceil < pins or complete?
+      a, b = *@edges.keys.sort_by { |v| -degree(v) }.pairs.find { |v1, v2| not @edges[v1].include? v2 }
       merge! a, b
     end
     self
@@ -63,14 +68,19 @@ module ArtDecomp class Graph
     self
   end
 
+  def vertices
+    @edges.keys.to_set
+  end
+
   private
 
   def merge! a, b
-    new_edges = adjacent(a, b).map { |vert| Set[a|b, vert] }
-    @vertices.subtract [a, b]
-    @vertices.add a|b
-    @edges.delete_if { |edge| edge.include? a or edge.include? b }
-    @edges.merge new_edges
+    new = a | b
+    adjs = adjacent(a) | adjacent(b)
+    adjs.each { |adj| @edges[adj] << new }
+    @edges[new] = adjs
+    @edges.delete(a).each { |adj| @edges[adj].delete a } unless a == new
+    @edges.delete(b).each { |adj| @edges[adj].delete b } unless b == new
   end
 
 end end

data/lib/core/enumerable.rb

@@ -1,22 +1,5 @@
 module Enumerable
 
-  def self.all_combinations source
-    result_count = source.map(&:size).inject :*
-    group_count = 1
-    result = []
-    source.each do |elems|
-      row = []
-      group_count.times do
-        elems.each do |elem|
-          (result_count / group_count / elems.size).times { row << elem }
-        end
-      end
-      group_count *= elems.size
-      result << row
-    end
-    result.transpose
-  end
-
   def pairs
     respond_to?(:combination) ? combination(2) : to_a.combination(2)
   end

data/spec/core/enumerable_spec.rb

@@ -11,10 +11,4 @@ describe Enumerable do
     array.pairs
   end
 
-  it 'should have a method to get all possible combinations of the passed elements' do
-    source = [[:a,:b], [:c], [:d,:e,:f]]
-    Enumerable.all_combinations(source).should == [[:a,:c,:d], [:a,:c,:e], [:a,:c,:f],
-                                                   [:b,:c,:d], [:b,:c,:e], [:b,:c,:f]]
-  end
-
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: art-decomp
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors: 
 - Piotr Szotkowski
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-13 00:00:00 +01:00
+date: 2010-01-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency