igraph 0.1.1 → 0.3

data/ext/cIGraph_topological_sort.c

@@ -0,0 +1,43 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.topological_sorting(mode) -> Array
+ *
+ * Calculate a possible topological sorting of the graph. A topological 
+ * sorting of a directed acyclic graph is a linear ordering of its nodes 
+ * where each node comes before all nodes to which it has edges. Every DAG 
+ * has at least one topological sort, and may have many. This function 
+ * returns a possible topological sort among them. If the graph is not 
+ * acyclic (it has at least one cycle), a partial topological sort is 
+ * returned and a warning is issued. mode specifies how to use the direction 
+ * of the edges. For IGRAPH_OUT, the sorting order ensures that each node 
+ * comes before all nodes to which it has edges, so nodes with no incoming 
+ * edges go first. For IGRAPH_IN, it is quite the opposite: each node comes 
+ * before all nodes from which it receives edges. Nodes with no outgoing 
+ * edges go first. 
+ */
+VALUE cIGraph_topological_sorting(VALUE self, VALUE mode){
+
+  igraph_t *graph;
+  igraph_vector_t res;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  VALUE result = rb_ary_new();
+  int i;
+
+  igraph_vector_init_int(&res,0);  
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_topological_sorting(graph, &res, pmode);
+
+  for(i=0;i<igraph_vector_size(&res);i++){
+    rb_ary_push(result,cIGraph_get_vertex_object(self,VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&res);
+
+  return result;
+
+}

data/ext/cIGraph_utility.c

@@ -4,12 +4,19 @@
 
 igraph_integer_t cIGraph_get_vertex_id(VALUE graph, VALUE v){
 
-  VALUE vertex_h;
+  VALUE v_ary;
+  VALUE idx;
+  igraph_t *igraph;
 
-  vertex_h = rb_iv_get(graph,"@object_ids");
+  Data_Get_Struct(graph, igraph_t, igraph);
+  v_ary = ((VALUE*)igraph->attr)[0];
 
-  if(rb_funcall(vertex_h,rb_intern("has_key?"),1,v))
-    return NUM2INT(rb_hash_aref(vertex_h,v));
+  idx   = rb_funcall(v_ary,rb_intern("index"),1,v);
+
+  if(idx != Qnil)
+    return NUM2INT(idx);
+
+  rb_raise(cIGraphError, "Unable to find vertex\n");
 
   return -1;
 
@@ -17,14 +24,16 @@ igraph_integer_t cIGraph_get_vertex_id(VALUE graph, VALUE v){
 
 VALUE cIGraph_get_vertex_object(VALUE graph, igraph_integer_t n){
 
-  VALUE vertex_h;
+  VALUE v_ary;
+  VALUE obj;
+  igraph_t *igraph;
 
-  vertex_h = rb_iv_get(graph,"@id_objects");
+  Data_Get_Struct(graph, igraph_t, igraph);
+  v_ary = ((VALUE*)igraph->attr)[0];
 
-  if(rb_funcall(vertex_h,rb_intern("has_key?"),1,INT2NUM(n)))
-    return rb_hash_aref(vertex_h,INT2NUM(n));
+  obj = rb_ary_entry(v_ary,n);
 
-  return Qnil;
+  return obj;
 
 }
 
@@ -32,6 +41,7 @@ int cIGraph_vertex_arr_to_id_vec(VALUE graph, VALUE va, igraph_vector_t *nv){
 
   VALUE vertex;
   VALUE tmp;
+  VALUE i;
 
   tmp = rb_check_array_type(va);
 
@@ -40,10 +50,9 @@ int cIGraph_vertex_arr_to_id_vec(VALUE graph, VALUE va, igraph_vector_t *nv){
     
   //Initialize edge vector
   igraph_vector_init_int(nv,0);
-  vertex = rb_ary_shift(va);
-  while(vertex != Qnil){
+  for (i=0; i<RARRAY(va)->len; i++) {
+    vertex = RARRAY(va)->ptr[i];
     igraph_vector_push_back(nv,cIGraph_get_vertex_id(graph, vertex));
-    vertex = rb_ary_shift(va);
   }
 
   return 0;
@@ -51,6 +60,12 @@ int cIGraph_vertex_arr_to_id_vec(VALUE graph, VALUE va, igraph_vector_t *nv){
 }
 
 VALUE cIGraph_include(VALUE self, VALUE v){
-  VALUE vertex_h = rb_iv_get(self,"@object_ids");
-  return rb_funcall(vertex_h,rb_intern("has_key?"),1,v);
+
+  VALUE v_ary;
+  igraph_t *igraph;
+
+  Data_Get_Struct(self, igraph_t, igraph);
+  v_ary = ((VALUE*)igraph->attr)[0];
+
+  return rb_ary_includes(v_ary,v);
 }

data/ext/cIGraph_vertex_neighbourhood.c

@@ -0,0 +1,158 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.neighbourhood_size(vertices,order,mode) -> Array
+ *
+ * Calculates the length of the shortest paths from each of the vertices in
+ * the varray Array to all of the other vertices in the graph. The result
+ * is returned as an Array of Array. Each top-level Array contains the results
+ * for a vertex in the varray Array. Each entry in the Array is the path length
+ * to another vertex in the graph in vertex order (the order the vertices were
+ * added to the graph. (This should probalby be changed to give a Hash of Hash
+ * to allow easier look up.)
+ */
+VALUE cIGraph_neighborhood_size(VALUE self, VALUE from, VALUE order, VALUE mode){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_t res;
+  int i;
+
+  VALUE sizes = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_init(&res,0);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_neighborhood_size(graph,&res,vids,NUM2INT(order),pmode);
+
+  for(i=0; i<igraph_vector_size(&res); i++){
+    rb_ary_push(sizes,INT2NUM(VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return sizes;
+
+}
+
+/* call-seq:
+ *   graph.neighbourhood(vertices,order,mode) -> Array
+ *
+ * Calculates the length of the shortest paths from each of the vertices in
+ * the varray Array to all of the other vertices in the graph. The result
+ * is returned as an Array of Array. Each top-level Array contains the results
+ * for a vertex in the varray Array. Each entry in the Array is the path length
+ * to another vertex in the graph in vertex order (the order the vertices were
+ * added to the graph. (This should probalby be changed to give a Hash of Hash
+ * to allow easier look up.)
+ */
+VALUE cIGraph_neighborhood(VALUE self, VALUE from, VALUE order, VALUE mode){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_ptr_t res;
+  igraph_vector_t *path_v;
+  int i;
+  int j;
+
+  VALUE matrix = rb_ary_new();
+  VALUE neighbourhood;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_neighborhood(graph,&res,vids,NUM2INT(order),pmode);
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    neighbourhood = rb_ary_new();
+    rb_ary_push(matrix,neighbourhood);
+    path_v = VECTOR(res)[i];
+    for(j=0; j<igraph_vector_size(VECTOR(res)[i]); j++){
+      rb_ary_push(neighbourhood,cIGraph_get_vertex_object(self,VECTOR(*path_v)[j]));
+    }
+  }
+
+  for(i=0;i<igraph_vector_ptr_size(&res);i++){
+    igraph_vector_destroy(VECTOR(res)[i]);
+  }  
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_ptr_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return matrix;
+
+}
+
+/* call-seq:
+ *   graph.neighbourhood_graph(vertices,order,mode) -> Array
+ *
+ * Calculates the length of the shortest paths from each of the vertices in
+ * the varray Array to all of the other vertices in the graph. The result
+ * is returned as an Array of Array. Each top-level Array contains the results
+ * for a vertex in the varray Array. Each entry in the Array is the path length
+ * to another vertex in the graph in vertex order (the order the vertices were
+ * added to the graph. (This should probalby be changed to give a Hash of Hash
+ * to allow easier look up.)
+ */
+VALUE cIGraph_neighborhood_graphs(VALUE self, VALUE from, VALUE order, VALUE mode){
+
+  igraph_t *graph;
+  igraph_t *n_graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_ptr_t res;
+  int i;
+
+  VALUE n_graph_obj;
+  VALUE result = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_neighborhood_graphs(graph,&res,vids,NUM2INT(order),pmode);
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    n_graph = VECTOR(res)[i];
+    n_graph_obj = Data_Wrap_Struct(cIGraph, cIGraph_mark, cIGraph_free, n_graph);
+    rb_ary_push(result,n_graph_obj);
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_ptr_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return result;
+
+}
+
+
+
+  

data/test/tc_add_delete.rb

@@ -46,4 +46,41 @@ class TestGraph < Test::Unit::TestCase
     assert_equal [0], graph.degree(['E'],IGraph::ALL,true)
   end
 
+  def test_delete_vertex
+    graph = IGraph.new(['A','B','C','D'],true,[1,2])
+    assert_nothing_raised do 
+      graph.delete_vertex('A')
+    end
+    assert_equal false, graph.include?('A')
+    assert_equal 3, graph.vcount
+    assert_equal 1, graph.ecount
+  end
+
+  def test_delete_edge
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_equal true, graph.are_connected?('A','B')
+    assert_nothing_raised do 
+      graph.delete_edge('A','B')
+    end
+    assert_equal false, graph.are_connected?('A','B')
+  end
+
+  def test_delete_edge_attr
+    graph = IGraph.new(['A','B','C','D'],true,[1,2])
+    assert_equal 1, graph['A','B']
+    assert_nothing_raised do 
+      graph.delete_edge('A','B')
+    end
+    assert_equal false, graph.are_connected?('A','B')
+    assert_equal 2, graph['C','D']
+  end
+
+  def test_delete_missing_edge
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_equal true, graph.are_connected?('A','B')
+    assert_raises(IGraphError) do 
+      graph.delete_edge('A','C')
+    end
+  end
+
 end

data/test/tc_attributes.rb

@@ -0,0 +1,29 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_get_attributes
+    graph = IGraph.new(['A','B','C','D'],true,[1,2])
+    assert_equal 2, graph.get_edge_attr('C','D')
+    assert_equal 2, graph['C','D']
+  end
+  def test_set_attributes
+    graph = IGraph.new(['A','B','C','D'],true,[1,2])
+    graph.set_edge_attr('C','D',3)
+    assert_equal 3, graph.get_edge_attr('C','D')
+    graph['C','D'] = 4
+    assert_equal 4, graph['C','D']
+  end
+  def test_new_edges
+    graph = IGraph.new(['A','B','C','D'],true,[1,2])
+    graph.add_edges(['A','C'],[3])
+    assert_equal 3, graph['A','C']
+    graph.add_edge('A','D',4)
+    assert_equal 4, graph['A','D']
+  end
+  def test_graph_attr
+    graph = IGraph.new(['A','B','C','D'],true,[1,2])
+    graph.attributes['test'] = 1
+    assert_equal 1, graph.attributes['test']
+  end
+end

data/test/tc_basic_properties.rb

@@ -3,7 +3,7 @@ require 'igraph'
 
 class TestGraph < Test::Unit::TestCase
   def test_are_connected
-    graph = IGraph.new(['A','B','C','D'],true)
+    graph = IGraph.new(['A','B','B','C','C','D'],true)
     assert graph.are_connected('A','B')
     assert !(graph.are_connected('A','C'))
   end

data/test/tc_centrality.rb

@@ -0,0 +1,33 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_closeness
+    g = IGraph.new(['A','B','B','C','C','D'],true)
+    assert_equal [0.75], g.closeness(['B'],IGraph::ALL)
+  end
+  def test_betweenness
+    g = IGraph.new(['A','B','B','C','C','D'],true)
+    assert_equal [0,2], g.betweenness(['A','B'],true)
+  end
+  def test_edge_betweenness
+    g = IGraph.new(['A','B','C','D'],true)
+    assert_equal [1,1], g.edge_betweenness(true)
+  end    
+  def test_pagerank
+    g = IGraph.new(['A','B','C','D','E','B','F','B'],true)
+    assert_equal 67, (g.pagerank(['B'],true,100,0.01,0.8)[0] * 100).to_i
+  end 
+  def test_constraint
+    g = IGraph.new(['A','B','C','D'],true)
+    assert_equal [1], g.constraint(['A'])    
+    assert_raises IGraphError do
+      g.constraint(['A'],[3])    
+    end
+    assert_equal [1], g.constraint(['A'],[2,3])    
+  end
+  def test_maxdegree
+    g = IGraph.new(['A','B','C','D','A','E','A','F'],true)
+    assert_equal 3, g.maxdegree(g.vertices,IGraph::ALL,true)        
+  end
+end

data/test/tc_components.rb

@@ -0,0 +1,25 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_subcomponent
+    g = IGraph.new([1,2,3,4])
+    assert_equal [1,2], g.subcomponent(1,IGraph::ALL)
+  end
+  def test_subgraph
+    g = IGraph.new([1,2,3,4])
+    h = g.subgraph([1,2])
+    assert_equal 2, h.vcount
+    assert_equal [1,2], h.vertices
+  end
+  def test_clusters
+    g  = IGraph.new([1,2,3,4])
+    assert_equal 2, g.clusters(IGraph::WEAK).length
+    assert_equal [1,2], g.clusters(IGraph::WEAK)[0]
+  end
+  def test_decompose
+    g = IGraph.new([1,2,3,4])
+    assert_equal 2, g.decompose(IGraph::WEAK).length
+    assert_equal [1,2], g.decompose(IGraph::WEAK)[0].vertices
+  end
+end

data/test/tc_copy.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_copy
+    g = IGraph.new(['A','B','C','D'],true,[1,2]);
+    h = g.dup
+    assert g.vcount == h.vcount
+    assert g['A','B'] == h['A','B']
+    h['A','B'] = g['A','B'] + 1
+    assert g['A','B'] != h['A','B']
+  end
+end

data/test/tc_file_read_write.rb

@@ -0,0 +1,161 @@
+require 'test/unit'
+require 'igraph'
+require 'stringio'
+
+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)
+    }
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert g.are_connected?(0,1)
+  end
+
+  def test_edgelist_write
+    g = IGraph.new([0,1,2,3])
+    s = StringIO.new("")
+    str = g.write_graph_edgelist(s)
+    s.rewind
+    assert_equal "0 1\n2 3\n", s.read
+  end
+
+  def test_graphml_read
+    g = nil
+    g = IGraph.read_graph_graphml(StringIO.new(Graphml),0)
+    assert_instance_of IGraph, g
+    assert_equal '2006-11-12', g.attributes['date']
+    h = g.dup
+    assert_equal g.to_a,h.to_a
+    assert_equal g.attributes['date'], h.attributes['date']
+  end
+
+  def test_graphml_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_graphml(s)
+    s.rewind
+    assert_equal Graphml_out, s.read
+  end
+
+  def test_pajek_read_write
+    g = nil
+    g = IGraph.read_graph_pajek(StringIO.new(Pajek),0)
+    assert_instance_of IGraph, g
+    assert_equal 4, g.vcount
+    assert_equal 1, g[4,1]['weight']
+    h = g.dup
+    s = StringIO.new('')
+    h.write_graph_pajek(s)
+    s.rewind
+    str = s.read
+    str.gsub!(/\r/,'')
+    #assert_equal Pajek, str
+  end
+
+  Graphml = %q{<?xml version="1.0" encoding="UTF-8"?>
+<!-- This file was written by the JAVA GraphML Library.-->
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"  xmlns:xsi="http://www.w3
+.org/2001/XMLSchema-instance"
+xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdr
+awing.org/xmlns/1.0/graphml.xsd">
+  <key id="d0" for="node" attr.name="color" attr.type="string">yellow</key>
+  <key id="d1" for="edge" attr.name="weight" attr.type="double"/>
+  <key id="d2" for="graph" attr.name="date" attr.type="string"></key>
+  <graph id="G" edgedefault="undirected">
+    <data key="d2">2006-11-12</data>
+    <node id="n0">
+      <data key="d0">green</data>
+      <data key="d3">incorrect</data>
+      <!-- incorrect attribute key, should issue a warning -->
+    </node>
+    <node id="n1"/>
+    <node id="n2">
+      <data key="d0">blue</data>
+    </node>
+    <node id="n3">
+      <data key="d0">red</data>
+    </node>
+    <node id="n4"/>
+    <node id="n5">
+      <data key="d0">turquoise</data>
+    </node>
+    <edge id="e0" source="n0" target="n2">
+      <data key="d1">1.0</data>
+    </edge>
+    <edge id="e1" source="n0" target="n1">
+      <data key="d1">1.0</data>
+    </edge>
+    <edge id="e2" source="n1" target="n3">
+      <data key="d1">2.0</data>
+    </edge>
+    <edge id="e3" source="n3" target="n2"/>
+    <edge id="e4" source="n2" target="n4"/>
+    <edge id="e5" source="n3" target="n5"/>
+    <edge id="e6" source="n5" target="n4">
+      <data key="d1">1.1</data>
+    </edge>
+  </graph>
+</graphml>
+}
+
+
+  Graphml_out = %q{<?xml version="1.0" encoding="UTF-8"?>
+<graphml xmlns="http://graphml.graphdrawing.org/xmlns"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns
+         http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd">
+<!-- Created by igraph -->
+  <key id="date" for="graph" attr.name="date" attr.type="string"/>
+  <key id="name" for="node" attr.name="name" attr.type="string"/>
+  <key id="type" for="node" attr.name="type" attr.type="double"/>
+  <key id="id" for="node" attr.name="id" attr.type="double"/>
+  <key id="eid" for="edge" attr.name="eid" attr.type="string"/>
+  <graph id="G" edgedefault="directed">
+    <data key="date">Friday</data>
+    <node id="n0">
+      <data key="name">a</data>
+      <data key="type">4</data>
+      <data key="id">0</data>
+    </node>
+    <node id="n1">
+      <data key="name">b</data>
+      <data key="type">5</data>
+      <data key="id">1</data>
+    </node>
+    <node id="n2">
+      <data key="name"></data>
+      <data key="type">6</data>
+      <data key="id">2</data>
+    </node>
+    <node id="n3">
+      <data key="name">d</data>
+      <data key="id">3</data>
+    </node>
+    <edge source="n0" target="n1">
+      <data key="eid">e1</data>
+    </edge>
+    <edge source="n2" target="n3">
+      <data key="eid">e2</data>
+    </edge>
+  </graph>
+</graphml>
+}
+
+  Pajek = %q{*Vertices 4
+*Edges
+4 1 1
+1 2 4
+1 3 2
+2 3 2
+}
+
+end