igraph 0.3.3 → 0.9.0

data/test/tc_community.rb

@@ -0,0 +1,72 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_modularity
+    g = IGraph.new(['A','B','B','C','A','C','C','D','D','E','E','F','D','F'])
+    assert_in_delta 0.357, g.modularity([['A','B','C'],['D','E','F']]), 0.001
+  end
+  def test_spinglass
+    g = IGraph.new(['A','B','B','C','A','C','C','D','D','E','E','F','D','F'])
+    groups,mod,temp = g.community_spinglass([],25,false,1,0.01,0.99,IGraph::SPINCOMM_UPDATE_SIMPLE,1.0)
+    assert_in_delta 0.25, mod,  0.15
+    assert_in_delta 0.200, temp, 0.100
+    assert_equal [['A','B','C','D','E','F']], groups
+    commun,coh,adh  = g.community_spinglass_single([],'A',25,IGraph::SPINCOMM_UPDATE_SIMPLE,1.0)
+    assert_in_delta 1.25, coh,  0.001
+    assert_in_delta(-2.5, adh, 0.100)
+    assert_equal ['A','B','C'], commun    
+  end
+  def test_eigen
+
+    g = IGraph.new(['A','B','B','C','A','C','C','D','D','E','E','F','D','F'],false)
+    groups,merges = g.community_leading_eigenvector(6)
+    assert_equal [['A','B','C'],['D','E','F']], groups
+    assert_equal [[0,1]], merges.to_a
+    groups,merges = g.community_leading_eigenvector_naive(6)
+    assert_equal [['A','B','C'],['D','E','F']], groups
+    assert_equal [[0,1]], merges.to_a
+
+    groups,split,eigenvec,eigenval = 
+      g.community_leading_eigenvector_step([['A','B','C','D','E','F']],0)
+    assert_equal [['A','B','C'],['D','E','F']], groups
+    assert split
+    assert_in_delta 0.433, eigenvec[0], 0.001
+    assert_in_delta 2.100, eigenval,    0.001
+
+  end
+
+  def test_random_walk
+    g = IGraph.new(['A','B','B','C','A','C','C','D','D','E','E','F','D','F'],false)
+    merges,modularity = g.community_walktrap([],10)
+    groups = g.community_to_membership(merges,4)
+    assert_equal [['A','B','C'],['D','E','F']], groups.sort
+    assert_in_delta 0.19, modularity[3], 0.1
+  end
+
+  def test_comm_edge_betweenness
+
+    g = IGraph.new(['A','B','B','C','A','C','C','D','D','E','E','F','D','F'],false)
+    merges,result,edge_betw,bridges = g.community_edge_betweenness(false)    
+    groups = g.community_to_membership(merges,4)
+    assert_equal [['A','B','C'],['D','E','F']], groups.sort
+    assert_equal 3, result[0]
+    assert_equal 9, edge_betw[0]
+    assert_equal 7, bridges[0]
+
+    merges,bridges = g.community_eb_get_merges(result)
+    groups = g.community_to_membership(merges,4)
+    assert_equal [['A','B','C'],['D','E','F']], groups.sort
+    assert_equal 7, bridges[0]    
+    
+  end
+
+  def test_fastgreedy
+    g = IGraph.new(['A','B','B','C','A','C','C','D','D','E','E','F','D','F'],false)
+    merges,mod = g.community_fastgreedy
+    groups = g.community_to_membership(merges,4)
+    assert_equal [['A','B','C'],['D','E','F']], groups.sort
+    assert_in_delta 0.19, mod[3], 0.1
+  end
+
+end

data/test/tc_connectivity.rb

@@ -0,0 +1,22 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_connecitivity
+    g = IGraph.new(['A','B','B','C','C','D'],true)
+    assert_equal 1, g.st_edge_connectivity('A','B')
+    assert_equal 0, g.edge_connectivity
+    assert_equal 1, g.st_vertex_connectivity('A','C',IGraph::VCONN_NEI_ERROR)
+    assert_equal 0, g.vertex_connectivity
+  end
+  def test_disjoint
+    g = IGraph.new(['A','B','B','C','C','D','A','E','E','D'],true)
+    assert_equal 2, g.edge_disjoint_paths('A','D')
+    assert_equal 2, g.vertex_disjoint_paths('A','D')
+  end
+  def test_adhesion
+    g = IGraph.new(['A','B','B','C','C','D'],true)
+    assert_equal 0, g.adhesion
+    assert_equal 0, g.cohesion   
+  end
+end

data/test/tc_file_read_write.rb

@@ -6,7 +6,7 @@ class TestGraph < Test::Unit::TestCase
   def test_edgelist_read
     g = nil
     assert_nothing_raised{
-      g = IGraph.read_graph_edgelist(StringIO.new("0 1 2 3"),true)
+      g = IGraph::FileRead.read_graph_edgelist(StringIO.new("0 1 2 3"),true)
     }
     assert_instance_of IGraph, g
     assert_equal 4, g.vcount
@@ -21,9 +21,96 @@ class TestGraph < Test::Unit::TestCase
     assert_equal "0 1\n2 3\n", s.read
   end
 
+  def test_ncol_read
+    g = nil
+    assert_nothing_raised{
+      g = IGraph::FileRead.read_graph_ncol(StringIO.new("0 1\n2 3\n"),[],
+				 false,false,false)
+    }
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert g.are_connected?(0,1)   
+
+    assert_nothing_raised{
+      g = IGraph::FileRead.read_graph_ncol(StringIO.new("A B\nC D\n"),[],
+				 true,false,false)
+    }
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert g.are_connected?('A','B')   
+    
+    assert_nothing_raised{
+      g = IGraph::FileRead.read_graph_ncol(StringIO.new("A B 1\nC D 2\n"),[],
+				 true,true,false)
+    }
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert g.are_connected?('A','B')       
+    assert_equal 1, g['A','B']
+  end
+
+  def test_ncol_write
+    g = IGraph.new(["A","B","C","D"],true,[1,2])
+    s = StringIO.new("")
+    str = g.write_graph_ncol(s,true,true)
+    s.rewind
+    assert_equal "A B 1.0\nC D 2.0\n", s.read
+  end
+
+  def test_lgl_read
+    g = nil
+    assert_nothing_raised{
+      g = IGraph::FileRead.read_graph_lgl(StringIO.new("#A\nB\n#C\nD\n"),
+				 false,false)
+    }
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert g.are_connected?(0,1)   
+
+    assert_nothing_raised{
+      g = IGraph::FileRead.read_graph_lgl(StringIO.new("#A\nB 1\n#C\nD 1\n"),
+				 true,true)
+    }
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert g.are_connected?('A','B')       
+    assert_equal 1, g['A','B']
+  end
+
+  def test_lgl_write
+    g = IGraph.new(["A","B","C","D"],true,[1,2])
+    s = StringIO.new("")
+    str = g.write_graph_lgl(s,true,true,false)
+    s.rewind
+    assert_equal "# A\nB 1.0\n# C\nD 2.0\n", s.read
+  end
+
+  def test_dimacs_read
+    g = nil
+    assert_nothing_raised{
+      s = StringIO.new("c com\np min 4 2\nn 1 s\nn 2 t\na 1 2 1\na 3 4 2\n")
+      g = IGraph::FileRead.read_graph_dimacs(s,
+				   false)
+    }
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert g.are_connected?(0,1)   
+    assert_equal 0, g.attributes['source']
+    assert_equal 1, g.attributes['target']
+    assert_equal [1,2], g.attributes['capacity']
+  end
+
+  def test_dimacs_write
+    g = IGraph.new(["A","B","C","D"],true,[1,2])
+    s = StringIO.new("")
+    str = g.write_graph_dimacs(s,0,1,[1,2])
+    s.rewind
+    assert_equal "c created by igraph\np max 4 2\nn 1 s\nn 2 t\na 1 2 1\na 3 4 2\n", s.read
+  end
+
   def test_graphml_read
     g = nil
-    g = IGraph.read_graph_graphml(StringIO.new(Graphml),0)
+    g = IGraph::FileRead.read_graph_graphml(StringIO.new(Graphml),0)
     assert_instance_of IGraph, g
     assert_equal '2006-11-12', g.attributes['date']
     h = g.dup
@@ -46,9 +133,31 @@ class TestGraph < Test::Unit::TestCase
     assert_equal Graphml_out, s.read
   end
 
+  def test_gml_read
+    g = IGraph::FileRead.read_graph_gml(StringIO.new(Gml))
+    assert_instance_of IGraph, g
+  end
+
+  def test_gml_write
+    g = IGraph.new([{'id'=>0,'name'=>'a','type' => 4.0},
+                    {'id'=>1,'name'=>'b','type' => 5},
+                    {'id'=>2,'type' => 6},
+                    {'id'=>3,'name'=>'d'}],
+                   true,
+                   [{'eid'=>'e1'},
+                    {'eid'=>'e2'}])
+    g.attributes['date'] = 'Friday'
+    s = StringIO.new("")
+    str = g.write_graph_gml(s)
+    s.rewind
+    s = s.read
+    s = s.split(/\n/)[1..-1].join("\n")
+    assert_equal Gml_out, s
+  end
+
   def test_pajek_read_write
     g = nil
-    g = IGraph.read_graph_pajek(StringIO.new(Pajek),0)
+    g = IGraph::FileRead.read_graph_pajek(StringIO.new(Pajek),0)
     assert_instance_of IGraph, g
     assert_equal 4, g.vcount
     assert_equal 1, g[4,1]['weight']
@@ -158,4 +267,85 @@ awing.org/xmlns/1.0/graphml.xsd">
 2 3 2
 }
 
+  Gml = %q{graph [
+    comment "This is a sample graph"
+    directed 1
+    id 42
+    label "Hello, I am a graph"
+    node [
+        id 1
+        label "Node 1"
+        thisIsASampleAttribute 42
+    ]
+    node [
+        id 2
+        label "node 2"
+        thisIsASampleAttribute 43
+    ]
+    node [
+        id 3
+        label "node 3"
+        thisIsASampleAttribute 44
+    ]
+    edge [
+        source 1
+        target 2
+        label "Edge from node 1 to node 2"
+    ]
+    edge [
+        source 2
+        target 3
+        label "Edge from node 2 to node 3"
+    ]
+    edge [
+        source 3
+        target 1
+        label "Edge from node 3 to node 1"
+    ]
+]
+}
+
+  Gml_out = %q{Version 1
+graph
+[
+  directed 0
+  date "Friday"
+  node
+  [
+    id 0
+    name "a"
+    type 4
+  ]
+  node
+  [
+    id 1
+    name "b"
+    type 5
+  ]
+  node
+  [
+    id 2
+    name ""
+    type 6
+  ]
+  node
+  [
+    id 3
+    name "d"
+    type nan
+  ]
+  edge
+  [
+    source 0
+    target 1
+    eid "e1"
+  ]
+  edge
+  [
+    source 2
+    target 3
+    eid "e2"
+  ]
+]}
+
 end

data/test/tc_generators_deterministic.rb

@@ -0,0 +1,61 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_adjacency
+    m = IGraphMatrix.new([0,1,1,0],[1,0,0,0],[1,0,0,1],[0,0,1,0])
+     
+    g = IGraph::Generate.adjacency(m,IGraph::ADJ_MAX)
+    assert_equal 4, g.vcount
+    assert_equal 3, g.ecount
+  end
+
+  def test_star
+    g = IGraph::Generate.star(10,IGraph::STAR_UNDIRECTED,0)
+    assert_equal 10, g.vcount
+    assert_equal  9, g.ecount
+  end
+
+  def test_lattice
+    g = IGraph::Generate.lattice([2,2],false,false,false)
+    assert_equal 4, g.vcount
+    assert_equal 4, g.ecount
+  end
+
+  def test_ring
+    g = IGraph::Generate.ring(10,false,false,false)
+    assert_equal 10, g.vcount
+    assert_equal 9, g.ecount
+  end
+
+  def test_tree
+    g = IGraph::Generate.tree(13,3,IGraph::TREE_UNDIRECTED)
+    assert_equal 13, g.vcount
+    assert_equal 12, g.ecount    
+  end
+
+  def test_full
+    g = IGraph::Generate.full(10,false,false)
+    assert_equal 10, g.vcount
+    assert_equal 45, g.ecount    
+  end
+
+  def test_atlas
+    g = IGraph::Generate.atlas(10)
+    assert_equal 4, g.vcount
+    assert_equal 2, g.ecount        
+  end
+
+  def test_extended_chordal_ring
+    g = IGraph::Generate.extended_chordal_ring(3,IGraphMatrix.new([1,2,3],[1,2,3],[1,2,3]))
+    assert_equal 3, g.vcount
+    assert_equal 6, g.ecount        
+  end
+
+  def test_connect_neighborhood
+    g = IGraph.new([1,2,1,3,3,4],false)
+    g.connect_neighborhood(2,IGraph::ALL)
+    assert g.are_connected?(2,3)
+  end
+
+end

data/test/tc_generators_random.rb

@@ -3,24 +3,98 @@ require 'igraph'
 
 class TestGraph < Test::Unit::TestCase
   def test_grg
-    g = IGraph.grg_game(10,0.1,false)
+    g = IGraph::GenerateRandom.grg_game(10,0.1,false)
     assert_equal 10, g.vertices.size
   end
   def test_barabasi
-    g = IGraph.barabasi_game(10,3,false,false)
+    g = IGraph::GenerateRandom.barabasi_game(10,3,false,false)
     assert_equal 10, g.vertices.size
   end
   def test_nonlinear_barabasi
-    g = IGraph.nonlinear_barabasi_game(10,1.9,3,false,0.1,false)
+    g = IGraph::GenerateRandom.nonlinear_barabasi_game(10,1.9,3,false,0.1,false)
     assert_equal 10, g.vertices.size
   end 
   def test_erdos_renyi
-    g = IGraph.erdos_renyi_game(IGraph::ERDOS_RENYI_GNP,10,0.5,false,false)
-    assert_equal 10, g.vertices.size    
-    g = IGraph.erdos_renyi_game(IGraph::ERDOS_RENYI_GNM,10,0.5,false,false)
-    assert_equal 10, g.vertices.size    
+    g = IGraph::GenerateRandom.erdos_renyi_game(IGraph::ERDOS_RENYI_GNP,10,0.5,false,false)
+    assert_instance_of IGraph, g    
+    g = IGraph::GenerateRandom.erdos_renyi_game(IGraph::ERDOS_RENYI_GNM,10,0.5,false,false)
+    assert_instance_of IGraph, g
   end
   def test_watts_strogatz
-    
+    g = IGraph::GenerateRandom.watts_strogatz_game(10,1,2,0.6)
+    assert_instance_of IGraph, g
   end
+  def test_degree_sequence_game
+    g = IGraph::GenerateRandom.degree_sequence_game([1,2,3],[1,2,3])
+    assert_instance_of IGraph, g
+  end
+  def test_growing_random_game
+    assert_instance_of IGraph, IGraph::GenerateRandom.growing_random_game(10,2,true,true)
+  end
+  def test_callaway_traits_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.callaway_traits_game(30,4,2,[0.25,0.25,0.25,0.25],
+                                IGraphMatrix.new([0,0.5,0.25,0.25],
+                                                 [0.5,0,0.25,0.25],
+                                                 [0.5,0.25,0,0.25],
+                                                 [0.5,0.25,0.25,0]),true)
+  end    
+  def test_establishment_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.establishment_game(30,4,2,[0.25,0.25,0.25,0.25],
+                              IGraphMatrix.new([0,0.5,0.25,0.25],
+                                               [0.5,0,0.25,0.25],
+                                               [0.5,0.25,0,0.25],
+                                               [0.5,0.25,0.25,0]),true)
+  end    
+  def test_preference_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.preference_game(30,4,[0.25,0.25,0.25,0.25],
+                           IGraphMatrix.new([0,0.5,0.25,0.25],
+                                            [0.5,0,0.25,0.25],
+                                            [0.5,0.25,0,0.25],
+                                            [0.5,0.25,0.25,0]),true,false)
+  end      
+  def test_asymmetric_preference_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.asymmetric_preference_game(30,4,
+                                      IGraphMatrix.new([0,0.5,0.25,0.25],
+                                                       [0.5,0,0.25,0.25],
+                                                       [0.5,0.25,0,0.25],
+                                                       [0.5,0.25,0.25,0]),
+                                      IGraphMatrix.new([0,0.5,0.25,0.25],
+                                                       [0.5,0,0.25,0.25],
+                                                       [0.5,0.25,0,0.25],
+                                                       [0.5,0.25,0.25,0]),
+                                      false)
+  end        
+  def test_recent_degree_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.recent_degree_game(30,2,4,5,false,0.1,true)
+  end          
+  def test_barabasi_aging_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.barabasi_aging_game(30,2,true,0.9,-0.5,3,0.1,0.1,2,2,true)
+  end 
+  def test_recent_degree_aging_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.recent_degree_aging_game(30,2,true,0.9,-0.5,3,4,0.1,true)
+  end   
+  def test_cited_type_game
+    assert_instance_of IGraph, 
+    IGraph::GenerateRandom.cited_type_game(10,(0..9).to_a,
+                           Array.new(5,0.5)+Array.new(5,0.2),
+                           2,true)
+  end
+  def test_citing_cited_type_Game
+  #  assert_instance_of IGraph, 
+  #  IGraph::GenerateRandom.citing_cited_type_game(4,(0..3).to_a,
+  #                                IGraphMatrix.new([0,0.5,0.25,0.25],
+  #                                                 [0.5,0,0.25,0.25],
+  #                                                 [0.5,0.25,0,0.25],
+  #                                                 [0.5,0.25,0.25,0]),
+  #                                1,
+  #                                true)
+  end
+  
 end