plexus 0.5.4 → 0.5.5

data/spec/digraph_spec.rb

@@ -0,0 +1,339 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Digraph" do # :nodoc:
+
+  before do
+    @single = Digraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
+    @dups   = DirectedPseudoGraph[1,2, 2,3, 3,4, 1,2, 2,3, 4,4]
+    @loops  = DirectedMultiGraph[1,2, 2,3, 3,4, 4,4, 1,2, 2,3]
+  end
+
+  describe "new" do
+    it do
+      @single.should == Digraph[1,2, 2,3, 3,4]
+      @dups.should == DirectedPseudoGraph.new([1,2, 2,3, 3,4, 1,2, 2,3])
+      @loops.should == DirectedMultiGraph.new([1,2, 2,3, 3,4, 4,4, 1,2, 2,3])
+      proc { Digraph.new(:loops) }.should raise_error(ArgumentError)
+      proc { Digraph.new(:parallel_edges) }.should raise_error(ArgumentError)
+      proc { DirectedMultiGraph.new(:loops) }.should raise_error(ArgumentError)
+      proc { DirectedMultiGraph.new(:parallel_edges) }.should raise_error(ArgumentError)
+      proc { DirectedPseudoGraph.new(:loops) }.should raise_error(ArgumentError)
+      proc { DirectedPseudoGraph.new(:parallel_edges) }.should raise_error(ArgumentError)
+      proc { Digraph.new(1) }.should raise_error(ArgumentError)
+      Digraph.new(@single).should == @single
+      DirectedPseudoGraph.new(@dups).should == @dups
+      DirectedMultiGraph.new(@loops).should == @loops
+      Digraph.new(@loops).should == Digraph[1,2, 2,3, 3,4]
+    end
+  end
+
+  describe "edges" do
+    it do
+      @single.edges.size.should == 3
+      @single.edges.include?(Arc[1,2]).should be_true
+      @single.edges.include?(Arc[2,3]).should be_true
+      @single.edges.include?(Arc[3,4]).should be_true
+      @single.edges.include?(Arc[4,4]).should be_false
+      @single.edges.include?(Arc[1,2]).should be_true
+      @single.edges.include?(Arc[2,3]).should be_true
+      @single.edges.include?(Arc[1,3]).should be_false
+      @single.edge?(2,3).should be_true
+      @single.edge?(1,4).should be_false
+      @single.edge?(Arc[1,2]).should be_true
+      @single.add_edge!(5,5).edge?(5,5).should be_false
+      @single.remove_edge!(5,5).edge?(5,5).should be_false
+
+      @dups.edges.size.should == 5
+      @dups.edges.include?(MultiArc[1,2]).should be_true
+      @dups.edges.include?(MultiArc[2,3]).should be_true
+      @dups.edges.include?(MultiArc[3,4]).should be_true
+      @dups.edges.include?(MultiArc[4,4]).should be_false
+      @dups.edges.include?(MultiArc[1,2]).should be_true
+      @dups.edges.include?(MultiArc[2,3]).should be_true
+      @dups.edges.include?(MultiArc[1,3]).should be_false
+      @dups.edge?(2,3).should be_true
+      @dups.edge?(1,4).should be_false
+      @dups.edge?(MultiArc[1,2]).should be_true
+      @dups.add_edge!(5,5).edge?(5,5).should be_false
+      proc {  @dups.remove_edge!(5,5)  }.should raise_error(ArgumentError)
+
+      @dups.edges.size.should == 5 
+      @loops.edges.include?(MultiArc[1,2]).should be_true
+      @loops.edges.include?(MultiArc[2,3]).should be_true
+      @loops.edges.include?(MultiArc[3,4]).should be_true
+      @loops.edges.include?(MultiArc[4,4]).should be_true
+      @loops.edges.include?(MultiArc[1,2]).should be_true
+      @loops.edges.include?(MultiArc[2,3]).should be_true
+      @loops.edges.include?(MultiArc[1,3]).should be_false
+      @loops.edge?(2,3).should be_true
+      @loops.edge?(1,4).should be_false
+      @loops.edge?(MultiArc[1,2]).should be_true
+      @loops.add_edge!(5,5).edge?(5,5).should be_true
+      proc {  @loops.remove_edge!(5,5)  }.should raise_error(ArgumentError)
+    end
+
+  end
+
+  describe "vertices" do
+    it do
+        @single.vertices.sort.should == [1,2,3,4]
+      @single.add_vertex!(5).to_a.sort.should == [1,2,3,4,5]
+        @single.remove_vertex!(3).to_a.sort.should == [1,2,4,5]
+      @single.vertex?(3).should be_false
+      @single.edge?(2,3).should be_false
+      @single.edge?(3,4).should be_false
+      @single.add_vertex(:bogus).vertex?(:bogus).should be_true
+      @single.add_vertex(:bogus).vertex?(nil).should be_false
+      @single.vertex?(:bogus).should be_false
+      @single.add_vertex!(:real)
+      @single.vertex?(:real).should be_true
+      @single.add_edge(:here, :there).edge?(Arc[:here, :there]).should be_true
+      @single.edge?(Arc[:here, :there]).should be_false
+      @single.vertex?(:here).should be_false
+      @single.vertex?(:there).should be_false
+      @single.add_edge!(:here, :there)
+      @single.edge?(Arc[:here, :there]).should be_true
+      @single.vertex?(:here).should be_true
+      @single.vertex?(:there).should be_true
+    end
+  end
+
+  describe "properties" do
+    it do
+      @single.should be_directed
+      @single.should_not be_empty
+      Digraph.new.should be_empty
+      @single.size.should == 4
+      @dups.size.should == 4
+      @loops.size.should == 4
+      @single.num_vertices.should == 4
+      @dups.num_vertices.should == 4
+      @single.num_edges.should == 3
+      @dups.num_edges.should == 5
+      @loops.num_edges.should == 6
+      @single.should be_oriented
+      @single.remove_vertex!(4)
+      @single.should be_oriented
+      @loops.oriented?.should be_false
+      @loops.remove_vertex!(4)
+      @loops.should be_oriented
+    end
+  end
+
+  describe "merge" do
+    it do
+      @dups.merge(@single)
+      @dups.num_edges.should == 8
+      @dups.vertices.sort.should == [1,2,3,4]
+    end
+  end
+
+  describe "operators" do
+    it do
+      result = @single + Arc[3,2] 
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 4
+      result.num_edges.should == 4
+
+      result = @single + 5
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 5
+      result.num_edges.should == 3
+
+      result = @single - Arc[4,4]
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 4
+      result.num_edges.should == 3
+
+      e = @loops.edges.detect { |e| e.source == 4 && e.target == 4 }
+      result = @loops - e
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 4
+      result.num_edges.should == 5
+
+      result = @single - 4
+      @single.size.should == 4
+      @single.num_edges.should == 3
+      result.size.should == 3
+      result.num_edges.should == 2
+      
+      @single << Arc[6,1]
+      @single.size.should == 5
+      @single.num_edges.should == 4
+      @single.edge?(6,1).should be_true
+    end
+  end
+
+  describe "reversal" do
+    it do
+      reverse = @single.add_vertex!(42).reversal
+      reverse.vertices.sort.should == [1,2,3,4,42]
+      reverse.edge?(2,1).should be_true
+      reverse.edge?(3,2).should be_true
+      reverse.edge?(4,3).should be_true
+      reverse.edge?(4,4).should be_false
+      reverse.num_edges.should == 3
+      reverse = @loops.reversal
+      reverse.edge?(4,4).should be_true
+    end
+  end
+
+  describe "complement" do
+    it do
+      complement = @single.complement 
+      complement.vertices.sort.should == [1,2,3,4]
+      complement.edge?(1,1).should be_false
+      complement.edge?(1,3).should be_true
+      complement.edge?(1,4).should be_true
+      complement.edge?(2,1).should be_true
+      complement.edge?(2,4).should be_true
+      complement.edge?(3,1).should be_true
+      complement.edge?(3,2).should be_true
+      complement.edge?(4,1).should be_true
+      complement.edge?(4,2).should be_true
+      complement.edge?(4,3).should be_true
+      complement.num_edges.should == 9
+
+      complement = @loops.complement 
+      complement.vertices.sort.should == [1,2,3,4]
+      complement.edge?(1,1).should be_true
+      complement.edge?(1,3).should be_true
+      complement.edge?(1,4).should be_true
+      complement.edge?(2,1).should be_true
+      complement.edge?(2,2).should be_true
+      complement.edge?(2,4).should be_true
+      complement.edge?(3,1).should be_true
+      complement.edge?(3,2).should be_true
+      complement.edge?(3,3).should be_true
+      complement.edge?(4,1).should be_true
+      complement.edge?(4,2).should be_true
+      complement.edge?(4,3).should be_true
+      complement.num_edges.should == 12
+    end
+  end
+
+  describe "induced_subgraph" do
+    it do
+      induced = @single.induced_subgraph([1,2])
+      induced.vertices.sort.should == [1,2]
+      induced.edge?(1,2).should be_true
+      induced.num_edges.should == 1
+    end
+  end
+
+  describe "include" do
+    it do
+      @single.include?(4).should be_true
+      @dups.include?(4).should be_true
+      @dups.include?(5).should be_false
+      @single.include?(5).should be_false
+      @single.include?(Arc[1,2]).should be_true
+      @dups.include?(Arc[1,2]).should be_true
+    end
+  end
+
+  describe "adjacent" do
+    it do
+
+      @single.adjacent?(2, Arc[1,2]).should be_true
+      @single.adjacent(1).should == [2]
+
+      @single.adjacent(1, :type=>:edges).should == [Arc[1,2]]
+      @single.adjacent(1, :type=>:edges, :direction=> :out).should == [Arc[1,2]]
+      @single.adjacent(2, :type=>:edges, :direction=> :in).should == [Arc[1,2]]
+      @single.adjacent(2, :type=>:edges, :direction=> :all).sort.should == [Arc[1,2],Arc[2,3]]
+
+      [[{},1], [{:direction => :out},1], [{:direction => :in},2]].each do |h,v|
+        adj = @dups.adjacent(v, h.merge(:type=>:edges))
+        adj.size.should == 2
+        adj.each do |e|
+          e.source == 1; e.target.should  == 2
+        end
+      end 
+      
+      adj = @dups.adjacent(2, {:type=>:edges,:direction=>:all})
+      adj.size.should == 4
+      adj.each do |e| 
+        ((e.source==1 and e.target==2) ||
+         (e.source==2 and e.target==3)).should be_true
+      end
+      
+        @single.adjacent(1, :type=>:vertices).should == [2]
+        @single.adjacent(1, :type=>:vertices, :direction=> :out).should == [2]
+        @single.adjacent(2, :type=>:vertices, :direction=> :in).should == [1]
+      @single.adjacent(2, :type=>:vertices, :direction=> :all).should == [1,3]
+
+      @single.adjacent(Arc[2,3], :type=>:vertices).should == [3]
+      @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :out).should == [3]
+      @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :in).should == [2]
+      @single.adjacent(Arc[2,3], :type=>:vertices, :direction=> :all).should == [2,3]
+
+      @single.adjacent(Arc[2,3], :type=>:edges).should == [Arc[3,4]]
+      @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :out).should == [Arc[3,4]]
+      @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :in).should == [Arc[1,2]]
+      @single.adjacent(Arc[2,3], :type=>:edges, :direction=> :all).sort.should == [Arc[1,2],Arc[3,4]]
+      
+      @dups.adjacent(MultiArc[2,3], :type=>:edges).should == [MultiArc[3,4]]
+      @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :out).should == [MultiArc[3,4]]
+      @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :in).should == [MultiArc[1,2]]*2
+      @dups.adjacent(MultiArc[2,3], :type=>:edges, :direction=> :all).sort.should == ([MultiArc[1,2]]*2+[MultiArc[3,4]])
+    end
+    
+  end
+
+  describe "neighborhood" do
+    it do
+      @single.neighborhood(1).sort.should == [2]
+      @single.neighborhood(2).sort.should == [1,3]
+      @single.neighborhood(Arc[2,3]).sort.should == [Arc[1,2], Arc[3,4]]
+    end
+  end
+
+  describe "degree" do
+    it do
+      @single.in_degree(1).should == 0
+      @single.in_degree(2).should == 1
+      @single.in_degree(4).should == 1
+      @loops.degree(4).should == 3
+      @loops.in_degree(4).should == 2
+      @single.out_degree(1).should == 1
+      @single.out_degree(2).should == 1
+      @single.out_degree(4).should == 0
+      @loops.out_degree(4).should == 1
+      @single.add_vertex!(6).out_degree(6).should == 0
+      @single.add_vertex!(7).in_degree(7).should == 0
+      @single.add_edge!(4,2).out_degree(4).should == 1
+      @loops.add_edge!(4,2).out_degree(4).should == 2
+      @single.in_degree(2).should == 2
+
+      @single.min_in_degree.should == 0
+      @single.max_in_degree.should == 2
+      @single.min_out_degree.should == 0
+      @single.max_out_degree.should == 1
+
+      @loops.min_in_degree.should == 0
+      @loops.max_in_degree.should == 2
+      @loops.min_out_degree.should == 1
+      @loops.max_out_degree.should == 2
+      @loops.degree(2).should == 4
+      @single.degree(1).should == 1
+      @loops.should_not be_regular
+      @single.should_not be_regular
+      @dups.should_not be_regular
+    end
+  end
+
+  describe "include" do
+    it do
+      @single.include?(2).should be_true
+      @single.include?(23).should be_false
+      @single.include?(Arc[1,2]).should be_true
+      @single.include?(Arc[1,4]).should be_false
+    end
+  end
+
+end

data/spec/dot_spec.rb

@@ -0,0 +1,48 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "Dot" do # :nodoc:
+  
+  DG_DOT = <<-DOT
+digraph  {
+    label = "Datacenters"
+    Miranda [
+        color = green,
+        style = filled,
+        label = "Miranda"
+    ]
+
+    Miranda -> Hillview [
+
+    ]
+
+    Miranda -> "San Francisco" [
+
+    ]
+
+    Miranda -> "San Jose" [
+
+    ]
+
+    Sunnyvale -> Miranda [
+
+    ]
+
+}
+DOT
+  
+  before do
+    @dg = DOT::DOTDigraph.new('label' => 'Datacenters')
+    @dg << DOT::DOTNode.new('name' => 'Miranda', 'color' => 'green', 'style' => 'filled')
+    @dg << DOT::DOTDirectedArc.new('from' => 'Miranda', 'to' => 'Hillview')
+    @dg << DOT::DOTDirectedArc.new('from' => 'Miranda', 'to' => '"San Francisco"')
+    @dg << DOT::DOTDirectedArc.new('from' => 'Miranda', 'to' => '"San Jose"')
+    @dg << DOT::DOTDirectedArc.new('from' => 'Sunnyvale', 'to' => 'Miranda')
+  end
+  
+  describe "generation" do
+    it do
+      @dg.to_s.should == DG_DOT
+    end
+  end
+  
+end

data/spec/edge_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+describe Arc do
+  before do
+    @e = Arc.new(1,2,'boo')
+    @u = Edge.new(1,2,'hoo')
+  end
+
+  describe "#edge_new" do
+    it do
+      proc { Arc.new }.should raise_error(ArgumentError)
+      proc { Arc.new(1) }.should raise_error(ArgumentError)
+      Arc.new(1,2).should be_a_kind_of(Arc)
+      Arc.new(1,2,'label').should be_a_kind_of(Arc)
+    end
+  end
+
+  describe "#edge_getters" do
+    it do
+      @e.source.should == 1
+      @e.target.should == 2
+      @e.label.should == 'boo'
+
+      @e[0].should == 1
+      @e[1].should == 2
+      @e[2].should == 'boo'
+
+      @e[-3].should == 1
+      @e[-2].should == 2
+      @e[-1].should == 'boo'
+
+      proc { @e[-4] }.should raise_error(IndexError)
+      proc { @e[3] }.should raise_error(IndexError)
+
+      @e['source'].should == 1
+      @e['target'].should == 2
+      @e['label'].should == 'boo'
+
+      @e[:source].should == 1
+      @e[:target].should == 2
+      @e[:label].should == 'boo'
+    end
+  end
+
+  describe "#edge_setters" do
+    it do
+      @e.source = 23
+      @e.target = 42
+      @e.label  = 'Yabba'
+      @e.source.should == 23
+      @e.target.should == 42
+      @e.label.should == 'Yabba'
+
+      @e['source'] = 2
+      @e['target'] = 1
+      @e['label']  = 'Dabba'
+      @e.source.should == 2
+      @e.target.should == 1
+      @e.label.should == 'Dabba'
+
+      @e[:source] = 9
+      @e[:target] = 8
+      @e['label'] = 'Doooo!'
+      @e.source.should == 9
+      @e.target.should == 8
+      @e.label.should == 'Doooo!'
+
+      @e[0] = 'Fred'
+      @e[1] = 'Flintstone'
+      @e[2] = 'and'
+      @e.source.should == 'Fred'
+      @e.target.should == 'Flintstone'
+      @e.label.should == 'and'
+
+      @e[-3] = 'Barney'
+      @e[-2] = 'Rubble'
+      @e[-1] = nil
+      @e.source.should == 'Barney'
+      @e.target.should == 'Rubble'
+      @e.label.should == nil
+    end
+  end
+
+  describe "#edge_simple_methods" do
+    it do
+      @e.to_a.should == [1,2,'boo']
+      @e.to_s.should == "(1-2 'boo')"
+      @e.label = nil
+      @e.to_s.should == "(1-2)"
+      @e.eql?(Arc.new(1,2)).should be_true
+      @e.eql?(Arc.new(1,3)).should be_false
+      Arc.new(2,1).eql?(@e).should be_false
+
+      @e.should == Arc.new(1,2)
+      @e.reverse.should == Arc.new(2,1)
+      Arc.new(1,2).should_not == Arc.new(1,3)
+      Arc.new(2,1).should_not == @e
+    end
+  end
+
+  describe "#edge_sort" do
+    it do
+      x = [ Arc.new(2,3), Arc.new(1,3), Arc.new(1,2), Arc.new(2,1) ].sort
+      x.should == [Arc.new(1,2), Arc.new(1,3), Arc.new(2,1), Arc.new(2,3)]
+    end
+  end
+
+  describe "#undirected_edge_new" do
+    it do
+      proc { Edge.new }.should raise_error(ArgumentError)
+      proc { Edge.new(1) }.should raise_error(ArgumentError)
+      Edge.new(1,2).should be_a_kind_of(Edge)
+      Edge.new(1,2,'label').should be_a_kind_of(Edge)
+    end
+  end
+
+  describe "#undirected_edge_getters" do
+    it do
+      @u.source.should == 1
+      @u.target.should == 2
+      @u.to_a.should == [1,2,'hoo']
+      @u.to_s.should == "(1=2 'hoo')"
+    end
+  end
+
+  describe "#undirected_edge_methods" do
+    it do
+      @u.label = nil
+      @u.to_s.should == "(1=2)"
+      Edge.new(2,1).to_s.should == "(1=2)"
+
+      @u.should == Edge.new(2,1)
+      @u.should == Edge.new(2,1,'boo')
+      @u.should_not == Edge.new(2,3)
+
+      Edge.new(2,1).hash.should == @u.hash
+    end
+  end
+
+  describe "#undirected_edge_sort" do
+    it do
+      x = [Edge.new(12, 1), Edge.new(2,11)].sort
+      x.should == [Edge.new(2,11), Edge.new(1,12)]
+    end
+  end
+
+  describe "#hash" do
+    it do
+      Arc[1,2,:c].should == Arc[1,2,:b]
+      Arc[1,2,:c].hash.should == Arc[1,2,:b].hash
+      Arc[1,2].should_not == Arc[2,1]
+      Arc[1,2].should_not == Edge[1,2]
+      Edge[1,2].should == Edge[2,1]
+      Edge[1,2,:a].should == Edge[2,1,:b]
+    end
+  end
+
+end