graph.njae 0.2.4 → 0.3.0

data/Gemfile

@@ -8,6 +8,5 @@ source "http://rubygems.org"
 group :development do
   gem "rspec", "~> 2.8.0"
   gem "bundler", "~> 1.0.0"
-  gem "jeweler", "~> 1.6.2"
-  gem "rdoc"
+  gem "jeweler", "~> 1.8.0"
 end

data/Gemfile.lock

@@ -3,10 +3,11 @@ GEM
   specs:
     diff-lcs (1.1.3)
     git (1.2.5)
-    jeweler (1.6.4)
+    jeweler (1.8.3)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
+      rdoc
     json (1.6.5)
     rake (0.9.2.2)
     rdoc (3.12)
@@ -25,6 +26,5 @@ PLATFORMS
 
 DEPENDENCIES
   bundler (~> 1.0.0)
-  jeweler (~> 1.6.2)
-  rdoc
+  jeweler (~> 1.8.0)
   rspec (~> 2.8.0)

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.3.0

data/graph.njae.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "graph.njae"
-  s.version = "0.2.4"
+  s.version = "0.3.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Neil Smith"]
-  s.date = "2012-03-05"
+  s.date = "2012-05-18"
   s.description = "A simple graph library"
   s.email = "neil.github@njae.me.uk"
   s.extra_rdoc_files = [
@@ -47,19 +47,16 @@ Gem::Specification.new do |s|
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_development_dependency(%q<rspec>, ["~> 2.8.0"])
       s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_development_dependency(%q<jeweler>, ["~> 1.6.2"])
-      s.add_development_dependency(%q<rdoc>, [">= 0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.8.0"])
     else
       s.add_dependency(%q<rspec>, ["~> 2.8.0"])
       s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-      s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
-      s.add_dependency(%q<rdoc>, [">= 0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.8.0"])
     end
   else
     s.add_dependency(%q<rspec>, ["~> 2.8.0"])
     s.add_dependency(%q<bundler>, ["~> 1.0.0"])
-    s.add_dependency(%q<jeweler>, ["~> 1.6.2"])
-    s.add_dependency(%q<rdoc>, [">= 0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.8.0"])
   end
 end
 

data/lib/graph.njae/edge.rb

@@ -10,8 +10,8 @@ module GraphNjae
   # Each connection is handled by a Graph::Connection object, so that each end
   # of the Edge can have it's own attributes.
   class Edge < OpenStruct
-    def initialize
-      super
+    def initialize(values = {})
+      super(values)
       self.connections = []
       self
     end
@@ -20,6 +20,7 @@ module GraphNjae
     def <<(other)
       c = Connection.new
       c.end = other
+      other.edges << self unless other.edges.include? self
       self.connections << c
       self
     end
@@ -33,13 +34,27 @@ module GraphNjae
     def connection_at(vertex)
       self.connections.find {|c| c.end.equal?  vertex}
     end
+    
+    # Return the vertex at the other end of the one given.
+    # Self-loops should still return the vertex
+    def other_end(vertex)
+      if self.vertices[0] == vertex
+        self.vertices[1]
+      else
+        self.vertices[0]
+      end
+    end
+    
+    def to_s
+      '<E: ' + self.type.to_s + ' [' + self.vertices.map {|n| n.to_s}.join(', ') + '] >'
+    end
   end
   
   # A connection between an Edge and a Vertex.The connection can have arbitrary attributes,
   # treated as method names.
   class Connection < OpenStruct
-    def initialize
-      super
+    def initialize(values = {})
+      super(values)
       self
     end
   end

data/lib/graph.njae/graph.rb

@@ -1,5 +1,9 @@
 require 'ostruct'
 
+require 'logger'
+$log = Logger.new(STDERR)
+$log.level = Logger::WARN
+
 # A simple graph library
 
 module GraphNjae
@@ -7,8 +11,8 @@ module GraphNjae
   # A container for all the parts of a graph.  The graph can have arbitrary attributes,
   # treated as method names.
   class Graph < OpenStruct
-    def initialize
-      super
+    def initialize(values = {})
+      super(values)
       self.edges = Array.new
       self.vertices = Array.new
       self
@@ -23,5 +27,94 @@ module GraphNjae
       end
       self
     end
-  end
+    
+    # Connects two vertices, creating and storing a new edge
+    # Also adds the vertices, unless they're already in the graph
+    def connect(vertex1, vertex2, edge_attributes = {})
+      self.vertices << vertex1 unless self.vertices.include? vertex1
+      self.vertices << vertex2 unless self.vertices.include? vertex2
+      edge = Edge.new(edge_attributes)
+      self.edges << edge
+      edge << vertex1 << vertex2
+    end
+    
+    # Form a product graph of this graph and the other.
+    # Return the product graph.
+    def product(other)
+      product_graph = Graph.new
+      self.vertices.each do |v1|
+        other.vertices.each do |v2|
+          product_graph << Vertex.new({:g1_vertex => v1, :g2_vertex => v2})
+        end
+      end
+      self.edges.each do |e1|
+        e1_vertices = e1.vertices
+        other.edges.each do |e2|
+          if e1.type == e2.type
+            e2_vertices = e2.vertices
+            source = product_graph.vertices.find {|v| v.g1_vertex == e1_vertices[0] and v.g2_vertex == e2_vertices[0]}
+            destination = product_graph.vertices.find {|v| v.g1_vertex == e1_vertices[1] and v.g2_vertex == e2_vertices[1]}
+            product_graph.connect source, destination
+            source = product_graph.vertices.find {|v| v.g1_vertex == e1_vertices[0] and v.g2_vertex == e2_vertices[1]}
+            destination = product_graph.vertices.find {|v| v.g1_vertex == e1_vertices[1] and v.g2_vertex == e2_vertices[0]}
+            product_graph.connect source, destination
+          end
+        end
+      end
+      product_graph.vertices.reject! {|v| v.neighbours.empty?}      
+      product_graph
+    end
+    
+    
+    def initial_similarity
+      self.vertices.each do |v|
+        if block_given?
+          v.initial_similarity = yield v
+        else
+          v.initial_similarity = 1.0
+        end
+        v.similarity = v.initial_similarity
+      end
+    end
+    
+    # Performs similarity flooding on a graph
+    # Assumes that the initial similarity has already been calculated
+    def similarity_flood(opts = {})
+      max_iterations = opts[:iterations] || 100
+      max_residual = opts[:max_residual] || 0.001
+      iteration = 1
+      residual = max_residual + 1
+      while residual > max_residual and iteration <= max_iterations
+        $log.debug { "Starting iteration #{iteration}" }
+        self.vertices.each do |v|
+          v.last_similarity = v.similarity
+        end
+        self.vertices.each do |v|
+          if block_given?
+            v.similarity = yield v
+          else
+            $log.debug { "Processing vertex #{v.name}" }
+            edge_groups = v.edges.group_by {|e| e.type }
+            $log.debug { "  Edge groups {#{edge_groups.keys.map {|t| t.to_s + ' => {' + edge_groups[t].map {|e| e.to_s}.join(', ')}.join('; ')}}" }
+            edge_groups.each do |type, edges|
+              $log.debug { "    Processing group type #{type}" }
+              n = edges.length
+              edges.each do |e|
+                e.other_end(v).similarity += v.last_similarity / n
+              end
+            end
+          end
+        end
+        max_similarity = vertices.map {|v| v.similarity}.max
+        self.vertices.each do |v|
+          v.similarity = v.similarity / max_similarity
+        end
+        residual = Math.sqrt(self.vertices.reduce(0) {|a, v| a += (v.similarity - v.last_similarity) ** 2})
+        $log.debug { puts "Residual = #{residual.round(3)}, sims = #{self.vertices.map {|v| v.name + " = " + v.similarity.round(2).to_s}}" }
+        iteration += 1
+      end
+      
+    end
+    
+  end # class
 end

data/lib/graph.njae/vertex.rb

@@ -6,19 +6,19 @@ module GraphNjae
   # A vertex in a graph. The edge can have arbitrary attributes,treated as 
   # method names.
   class Vertex < OpenStruct
-    def initialize
-      super
+    def initialize(values = {})
+      super(values)
       self.edges = []
       self
     end
     
     # Connect this vertex to another, creating an Edge to do so, and returning
     # the Edge
-    def connect(other)
-      e = Edge.new
+    def connect(other, edge_attributes = {})
+      e = Edge.new edge_attributes
       e << self << other
-      self.edges << e
-      other.edges << e unless self === other
+      # self.edges << e
+      # other.edges << e unless self === other
       e
     end
     
@@ -39,5 +39,9 @@ module GraphNjae
                       e.vertices.drop_while {|v| v != self}[1..-1]}.flatten
     end
     
+    def to_s
+      '<V: ' + self.name + '>'
+    end
+    
   end
 end

data/spec/graph/edge_spec.rb

@@ -8,6 +8,14 @@ module GraphNjae
         e = Edge.new
         e.connections.should be_empty
       end
+      
+      it "creates an edge with some parameters" do
+        e = Edge.new :value1 => 1, :value2 => "value2", :value3 => :v3
+        e.value1.should == 1
+        e.value2.should == "value2"
+        e.value3.should == :v3
+        e.value4.should be_nil
+      end
     end # #initialize
     
     describe "adds attribues" do
@@ -20,23 +28,25 @@ module GraphNjae
     describe "#<<" do
       it "adds a new vertex to an edge (with a connection)" do
         e.connections.should be_empty
-        v1 = Vertex.new
-        v2 = Vertex.new
+        v1 = Vertex.new :name => :v1
+        v2 = Vertex.new :name => :v2
         e << v1
         e.should have(1).connections
         e.should have(1).vertices
         e.vertices.should include(v1)
+        v1.edges.should include(e)
         e << v2
         e.should have(2).connections
         e.should have(2).vertices
         e.vertices.should include(v1)
         e.vertices.should include(v2)
+        v2.edges.should include(e)
       end
       
       it "adds several vertices to an edge" do
         e.connections.should be_empty
-        v1 = Vertex.new
-        v2 = Vertex.new
+        v1 = Vertex.new :name => :v1
+        v2 = Vertex.new :name => :v2
         e << v1 << v2
         e.vertices.should include(v1)
         e.vertices.should include(v2)
@@ -56,8 +66,8 @@ module GraphNjae
     describe "connection_at" do
       it "returns the connection that links to a vertex" do
         e.connections.should be_empty
-        v1 = Vertex.new
-        v2 = Vertex.new
+        v1 = Vertex.new :name => :v1
+        v2 = Vertex.new :name => :v2
         e << v1 << v2
         
         e.connection_at(v1).end.should be v1
@@ -66,9 +76,9 @@ module GraphNjae
       
       it "returns nil if there is no connection to that vertex" do
         e.connections.should be_empty
-        v1 = Vertex.new
-        v2 = Vertex.new
-        v3 = Vertex.new
+        v1 = Vertex.new :name => :v1
+        v2 = Vertex.new :name => :v2
+        v3 = Vertex.new :name => :v3
         e << v1 << v2
         
         e.connection_at(v3).should be nil
@@ -76,14 +86,49 @@ module GraphNjae
       
       it "returns the vertex for a self-loop" do
         e.connections.should be_empty
-        v1 = Vertex.new
+        v1 = Vertex.new :name => :v1
         e << v1 << v1
         
         e.connection_at(v1).end.should be v1
       end
-
-    
     end # #connection_at
+    
+    describe "other_end" do
+      it "returns the vertex at the other end of the given one" do
+        e.connections.should be_empty
+        v1 = Vertex.new :name => :v1
+        v2 = Vertex.new :name => :v2
+        e << v1 << v2
+        
+        e.other_end(v1).should be v2
+        e.other_end(v2).should be v1
+      end
+      
+      it "returns the same vertex in a self-loop" do
+        e.connections.should be_empty
+        v1 = Vertex.new :name => :v1
+        e << v1 << v1
+        
+        e.other_end(v1).should be v1
+      end
+      
+      it "returns one of the connected edges if given a vertex not connected to it" do
+        e.connections.should be_empty
+        v1 = Vertex.new :name => :v1
+        v2 = Vertex.new :name => :v2
+        v3 = Vertex.new :name => :v3
+        e << v1 << v2
+        
+        [v1, v2].should include e.other_end(v3)
+      end 
+      
+      it "returns nil if it can't return something sensible" do
+        v1 = Vertex.new :name => :v1
+        e.other_end(v1).should be_nil
+        e << v1
+        e.other_end(v1).should be_nil
+      end
+    end # other_end
   end # Edge
   
   describe Connection do

data/spec/graph/graph_spec.rb

@@ -16,12 +16,21 @@ module GraphNjae
         g.edges.should be_empty
         g.vertices.should be_empty
       end
+      
+      it "creates a graph with some parameters" do
+        g = Graph.new :value1 => 1, :value2 => "value2", :value3 => :v3
+        g.value1.should == 1
+        g.value2.should == "value2"
+        g.value3.should == :v3
+        g.value4.should be_nil
+      end
+
     end # #initialize
       
-    describe "adds attribues" do
+    describe "adds attributes" do
       it "adds then reports arbitrary attributes" do
         g.score = 15
-        g.score == 15
+        g.score.should == 15
       end
     end # adds attributes
     
@@ -75,8 +84,402 @@ module GraphNjae
 
     describe "connect" do
       it "adds and records an edge between vertices" do
+        g.vertices.should be_empty
+        g.edges.should be_empty
+        v1 = Vertex.new(:name => :v1)
+        v2 = Vertex.new(:name => :v2)
+        g.connect(v1, v2)
+        
+        g.should have(2).vertices
+        g.vertices.should include(v1)
+        g.vertices.should include(v2)
+        g.should have(1).edges
+      end
+      
+      it "adds and records an edge with attributes between vertices" do
+        g.vertices.should be_empty
+        g.edges.should be_empty
+        v1 = Vertex.new(:name => :v1)
+        v2 = Vertex.new(:name => :v2)
+        g.connect(v1, v2, :type => :edge_type)
+        
+        g.should have(2).vertices
+        g.vertices.should include(v1)
+        g.vertices.should include(v2)
+        g.should have(1).edges
+        g.edges[0].type.should == :edge_type
       end
     end # #connect
     
+    describe "product" do
+      it "finds a product graph of a pair of one-vertex graphs" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new
+        g1 << g1v1
+        g2v1 = Vertex.new
+        g2 << g2v1
+        product = g1.product g2
+        
+        product.vertices.should be_empty
+        #product.vertices.first.g1_vertex.should == g1v1
+        #product.vertices.first.g2_vertex.should == g2v1
+        product.edges.should be_empty
+      end
+
+      it "finds a product graph of a pair of simple graphs" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1.connect(g1v1, g1v2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2.connect(g2v1, g2v2)
+        pg = g1.product g2
+        
+        pg.should have(4).vertices
+        pg.should have(2).edges
+      end
+      
+      it "finds a product graph of not-quite-simple graph" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1v3 = Vertex.new(:name => :g1v3)
+        g1.connect(g1v1, g1v2)
+        g1.connect(g1v2, g1v3)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2v3 = Vertex.new(:name => :g2v3)
+        g2.connect(g2v1, g2v2)
+        g2.connect(g2v2, g2v3)
+        pg = g1.product g2
+        
+        pg.should have(9).vertices
+        pg.should have(8).edges
+      end
+
+      it "finds a product graph of a simple graph with edge types" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1v3 = Vertex.new(:name => :g1v3)
+        g1.connect(g1v1, g1v2, :type => :t1)
+        g1.connect(g1v2, g1v3, :type => :t2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2v3 = Vertex.new(:name => :g2v3)
+        g2.connect(g2v1, g2v2, :type => :t1)
+        g2.connect(g2v2, g2v3, :type => :t2)
+        pg = g1.product g2
+        
+        pg.should have(7).vertices
+        pg.should have(4).edges
+      end
+
+      it "finds a product graph of the example graph from paper" do
+        pending "implementation of directed graphs as operands of the product graph"
+        g1 = Graph.new
+        g2 = Graph.new
+        a = Vertex.new(:name => :a)
+        a1 = Vertex.new(:name => :a1)
+        a2 = Vertex.new(:name => :a2)
+        g1.connect(a, a1, :type => :l1)
+        g1.connect(a, a2, :type => :l1)
+        g1.connect(a1, a2, :type => :l2)
+        b = Vertex.new(:name => :b)
+        b1 = Vertex.new(:name => :b1)
+        b2 = Vertex.new(:name => :b2)
+        g2.connect(b, b1, :type => :l1)
+        g2.connect(b, b2, :type => :l2)
+        g2.connect(b1, b2, :type => :l2)
+        pg = g1.product g2
+
+        pg.should have(4).edges
+        pg.should have(6).vertices
+      end
+
+      
+    end #product
+    
+    describe "initial_similarity" do
+      before(:each) do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1.connect(g1v1, g1v2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2.connect(g2v1, g2v2)
+        @pg = g1.product g2
+      end
+      
+      def simple_name_similarity(n1, n2)
+        1 - n1.to_s.codepoints.to_a.delete_if {|c| n2.to_s.codepoints.to_a.include? c}.length / n1.to_s.length.to_f
+      end
+
+      it "should give all nodes an initial similarity of 1 if no block is given" do
+        @pg.initial_similarity
+        @pg.vertices.each do |v|
+          v.initial_similarity.should be_within(0.001).of(1.0)
+          v.similarity.should be_within(0.001).of(1.0)
+        end
+      end
+      
+      it "should give all nodes the similarity as defined by the given block" do
+        @pg.initial_similarity {|v| simple_name_similarity v.g1_vertex.name, v.g2_vertex.name}
+        @pg.vertices.each do |v|
+          v.initial_similarity.should be_within(0.001).of( simple_name_similarity v.g1_vertex.name, v.g2_vertex.name )
+          v.similarity.should be_within(0.001).of( simple_name_similarity v.g1_vertex.name, v.g2_vertex.name )
+        end
+
+      end
+    end #initial similarity
+    
+    describe "similarity flood" do
+      it "similarity floods a graph of two nodes" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1.connect(g1v1, g1v2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2.connect(g2v1, g2v2)
+        pg = g1.product g2
+
+        pg.initial_similarity
+        pg.similarity_flood
+        pg.vertices.each do |v|
+          v.similarity.should be_within(0.001).of(1.0)
+        end
+      end
+        
+      it "similarity floods a graph of three nodes, a -- b -- c" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1v3 = Vertex.new(:name => :g1v3)
+        g1.connect(g1v1, g1v2, :type => :t1)
+        g1.connect(g1v2, g1v3, :type => :t2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2v3 = Vertex.new(:name => :g2v3)
+        g2.connect(g2v1, g2v2, :type => :t1)
+        g2.connect(g2v2, g2v3, :type => :t2)
+        pg = g1.product g2
+        
+        pg.initial_similarity
+        pg.similarity_flood
+        expected_similarities = {
+          "g1v1:g2v1" => 0.5,
+          "g1v1:g2v2" => 0.6666666666666666,
+          "g1v2:g2v1" => 0.6666666666666666,
+          "g1v2:g2v2" => 1.0,
+          "g1v2:g2v3" => 0.6666666666666666,
+          "g1v3:g2v2" => 0.6666666666666666,
+          "g1v3:g2v3" => 0.5}
+        pg.vertices.each do |v|
+          name = v.g1_vertex.name.to_s + ':' + v.g2_vertex.name.to_s
+          v.similarity.should be_within(0.001).of(expected_similarities[name])
+        end
+      end
+        
+      it "simialrity floods the sample graph from the paper" do
+        pg = Graph.new
+        ab = Vertex.new(:name => "a:b")
+        a1b1 = Vertex.new(:name => "a1:b1")
+        a2b1 = Vertex.new(:name => "a2:b1")
+        a1b2 = Vertex.new(:name => "a1:b2")
+        a1b = Vertex.new(:name => "a1:b")
+        a2b2 = Vertex.new(:name => "a2:b2")
+        pg.connect(ab, a1b1, :type => :l1)
+        pg.connect(ab, a2b1, :type => :l1)
+        pg.connect(a2b1, a1b2, :type => :l2)
+        pg.connect(a1b, a2b2, :type => :l2)
+        pg.initial_similarity
+        pg.similarity_flood 
+
+        expected_similarities = {
+          "a:b" => 1.0,
+          "a2:b1" => 0.92,
+          "a1:b2" => 0.71,
+          "a1:b1" => 0.38,
+          "a1:b" => 0.0,
+          "a2:b2" => 0.0}
+        pg.vertices.each do |v|
+          v.similarity.should be_within(0.02).of(expected_similarities[v.name])
+        end
+      end
+      
+      it "similarity floods a graph of three nodes, a -- b -- c, given a block that performs the default update" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1v3 = Vertex.new(:name => :g1v3)
+        g1.connect(g1v1, g1v2, :type => :t1)
+        g1.connect(g1v2, g1v3, :type => :t2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2v3 = Vertex.new(:name => :g2v3)
+        g2.connect(g2v1, g2v2, :type => :t1)
+        g2.connect(g2v2, g2v3, :type => :t2)
+        pg = g1.product g2
+        
+        pg.initial_similarity
+        pg.similarity_flood do |v|
+          edge_groups = v.edges.group_by {|e| e.type }
+          edge_groups.each do |type, edges|
+            n = edges.length
+            edges.each do |e|
+              e.other_end(v).similarity += v.last_similarity / n
+            end
+          end
+          v.similarity
+        end
+        expected_similarities = {
+          "g1v1:g2v1" => 0.5,
+          "g1v1:g2v2" => 0.6666666666666666,
+          "g1v2:g2v1" => 0.6666666666666666,
+          "g1v2:g2v2" => 1.0,
+          "g1v2:g2v3" => 0.6666666666666666,
+          "g1v3:g2v2" => 0.6666666666666666,
+          "g1v3:g2v3" => 0.5}
+        pg.vertices.each do |v|
+          name = v.g1_vertex.name.to_s + ':' + v.g2_vertex.name.to_s
+          v.similarity.should be_within(0.001).of(expected_similarities[name])
+        end
+      end
+
+      it "similarity floods a graph of three nodes, a -- b -- c, given a block that performs a different update (method A)" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1v3 = Vertex.new(:name => :g1v3)
+        g1.connect(g1v1, g1v2, :type => :t1)
+        g1.connect(g1v2, g1v3, :type => :t2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2v3 = Vertex.new(:name => :g2v3)
+        g2.connect(g2v1, g2v2, :type => :t1)
+        g2.connect(g2v2, g2v3, :type => :t2)
+        pg = g1.product g2
+        
+        pg.initial_similarity
+        pg.similarity_flood do |v|
+          v.similarity = v.initial_similarity
+          edge_groups = v.edges.group_by {|e| e.type }
+          edge_groups.each do |type, edges|
+            n = edges.length
+            edges.each do |e|
+              e.other_end(v).similarity += v.last_similarity / n
+            end
+          end
+          v.similarity
+        end
+        expected_similarities = {
+          "g1v1:g2v1" => 0.9269662921348315,
+          "g1v1:g2v2" => 1.0,
+          "g1v2:g2v1" => 0.6179775280898876,
+          "g1v2:g2v2" => 1.0,
+          "g1v2:g2v3" => 1.0,
+          "g1v3:g2v2" => 0.6179775280898876,
+          "g1v3:g2v3" => 0.6179775280898876}
+        pg.vertices.each do |v|
+          name = v.g1_vertex.name.to_s + ':' + v.g2_vertex.name.to_s
+          v.similarity.should be_within(0.001).of(expected_similarities[name])
+        end
+      end
+
+      it "similarity floods a graph of three nodes, a -- b -- c, given a block that performs a different update (method B)" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1v3 = Vertex.new(:name => :g1v3)
+        g1.connect(g1v1, g1v2, :type => :t1)
+        g1.connect(g1v2, g1v3, :type => :t2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2v3 = Vertex.new(:name => :g2v3)
+        g2.connect(g2v1, g2v2, :type => :t1)
+        g2.connect(g2v2, g2v3, :type => :t2)
+        pg = g1.product g2
+        
+        pg.initial_similarity
+        pg.similarity_flood do |v|
+          v.similarity = 0.0
+          edge_groups = v.edges.group_by {|e| e.type }
+          edge_groups.each do |type, edges|
+            n = edges.length
+            edges.each do |e|
+              e.other_end(v).similarity += (v.initial_similarity + v.last_similarity) / n
+            end
+          end
+          v.similarity
+        end
+        expected_similarities = {
+          "g1v1:g2v1" => 1.0,
+          "g1v1:g2v2" => 1.0,
+          "g1v2:g2v1" => 0.0,
+          "g1v2:g2v2" => 1.0,
+          "g1v2:g2v3" => 1.0,
+          "g1v3:g2v2" => 0.0,
+          "g1v3:g2v3" => 0.0}
+        pg.vertices.each do |v|
+          name = v.g1_vertex.name.to_s + ':' + v.g2_vertex.name.to_s
+          v.similarity.should be_within(0.001).of(expected_similarities[name])
+        end
+      end
+
+      it "similarity floods a graph of three nodes, a -- b -- c, given a block that performs a different update (method C)" do
+        g1 = Graph.new
+        g2 = Graph.new
+        g1v1 = Vertex.new(:name => :g1v1)
+        g1v2 = Vertex.new(:name => :g1v2)
+        g1v3 = Vertex.new(:name => :g1v3)
+        g1.connect(g1v1, g1v2, :type => :t1)
+        g1.connect(g1v2, g1v3, :type => :t2)
+        g2v1 = Vertex.new(:name => :g2v1)
+        g2v2 = Vertex.new(:name => :g2v2)
+        g2v3 = Vertex.new(:name => :g2v3)
+        g2.connect(g2v1, g2v2, :type => :t1)
+        g2.connect(g2v2, g2v3, :type => :t2)
+        pg = g1.product g2
+        
+        pg.initial_similarity
+        pg.similarity_flood do |v|
+          v.similarity = v.initial_similarity + v.last_similarity
+          edge_groups = v.edges.group_by {|e| e.type }
+          edge_groups.each do |type, edges|
+            n = edges.length
+            edges.each do |e|
+              e.other_end(v).similarity += (v.initial_similarity + v.last_similarity) / n
+            end
+          end
+          v.similarity
+        end
+        expected_similarities = {
+          "g1v1:g2v1" => 0.8282781862745098,
+          "g1v1:g2v2" => 1.0,
+          "g1v2:g2v1" => 0.41421568627450983,
+          "g1v2:g2v2" => 1.0,
+          "g1v2:g2v3" => 1.0,
+          "g1v3:g2v2" => 0.41421568627450983,
+          "g1v3:g2v3" => 0.41421568627450983}
+        pg.vertices.each do |v|
+          name = v.g1_vertex.name.to_s + ':' + v.g2_vertex.name.to_s
+          v.similarity.should be_within(0.001).of(expected_similarities[name])
+        end
+      end
+    end # similarity_flood
+    
   end
 end

data/spec/graph/vertex_spec.rb

@@ -9,6 +9,14 @@ module GraphNjae
         v = Vertex.new
         v.edges.should be_empty
       end
+      
+      it "creates a vertex with some parameters" do
+        v = Vertex.new :value1 => 1, :value2 => "value2", :value3 => :v3
+        v.value1.should == 1
+        v.value2.should == "value2"
+        v.value3.should == :v3
+        v.value4.should be_nil
+      end
     end # #initialize
     
     describe "adds attribues" do
@@ -77,9 +85,16 @@ module GraphNjae
         e.vertices.should include(v)
         e.vertices.should include(v1)
 
-              e.should have(2).connections
+        e.should have(2).connections
       end
 
+      it "connects two vertices by an edge with attributes" do
+        v1 = Vertex.new
+        v1.id = :v1
+        e = v.connect(v1, {:type => :edge_type})
+        e.type.should == :edge_type
+      end
+      
       it "creates a self-connection" do
         e = v.connect v
         
@@ -96,6 +111,11 @@ module GraphNjae
         e.should have(2).connections
       end
 
+      it "creates a self-connection with an edge with attributes" do
+        e = v.connect(v, {:type => :edge_type})
+        e.type.should == :edge_type
+      end
+
     end # #connect
     
     describe "#neighbours" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: graph.njae
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-05 00:00:00.000000000 Z
+date: 2012-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &85433160 !ruby/object:Gem::Requirement
+  requirement: &76981430 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 2.8.0
   type: :development
   prerelease: false
-  version_requirements: *85433160
+  version_requirements: *76981430
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &85432740 !ruby/object:Gem::Requirement
+  requirement: &76981190 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,29 +32,18 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *85432740
+  version_requirements: *76981190
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &85432370 !ruby/object:Gem::Requirement
+  requirement: &76980930 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.6.2
+        version: 1.8.0
   type: :development
   prerelease: false
-  version_requirements: *85432370
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: &85431930 !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: *85431930
+  version_requirements: *76980930
 description: A simple graph library
 email: neil.github@njae.me.uk
 executables: []
@@ -95,7 +84,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 841005965
+      hash: 727460339
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements: