igraph 0.1.1

data/ext/cIGraph_selectors.c

@@ -0,0 +1,93 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.vertices -> Array
+ *
+ * Returns an Array containing all the vertices in the graph. Also aliased
+ * to IGraph#all_vertices
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.vertices #returns [1,2,3,4]
+ *
+ */
+VALUE cIGraph_all_v(VALUE self){
+  igraph_t *graph;  
+
+  Data_Get_Struct(self, igraph_t, graph);
+  return rb_funcall(rb_iv_get(self,"@object_ids"),rb_intern("keys"),0);
+
+}
+
+/* call-seq:
+ *   graph.adjacent_vertices(v,mode) -> Array
+ *
+ * Returns an Array containing all the vertices in the graph that are 
+ * adjacent to vertex v. mode decides the type of the neighborhood for 
+ * directed graphs. Possible values: IGRAPH_OUT, all vertices to which 
+ * there is a directed edge from vid. IGRAPH_IN, all vertices from which 
+ * there is a directed edge from vid. IGRAPH_ALL, all vertices to which 
+ * or from which there is a directed edge from/to vid. This parameter is 
+ * ignored for undirected graphs.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.adjacent_vertices(1,IGraph::ALL) #returns [2]
+ *
+ */
+VALUE cIGraph_adj_v(VALUE self, VALUE v, VALUE mode){
+
+  igraph_t *graph;  
+  igraph_integer_t pnode;
+  VALUE adjacent = rb_ary_new();
+  igraph_neimode_t pmode = NUM2INT(mode);  
+  igraph_vs_t vs;
+  igraph_vit_t vit;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  pnode = cIGraph_get_vertex_id(self,v);
+
+  igraph_vs_adj(&vs,pnode,pmode);
+  igraph_vit_create(graph, vs, &vit);
+
+  while(!IGRAPH_VIT_END(vit)) {
+    rb_ary_push(adjacent,cIGraph_get_vertex_object(self,IGRAPH_VIT_GET(vit)));
+    IGRAPH_VIT_NEXT(vit);
+  }
+
+  igraph_vit_destroy(&vit);
+  igraph_vs_destroy(&vs);  
+
+  return adjacent;
+
+}
+
+VALUE cIGraph_nonadj_v(VALUE self, VALUE v, VALUE mode){
+
+  return Qnil;
+
+}
+
+VALUE cIGraph_all_e(VALUE self, VALUE mode){
+
+  return Qnil;
+
+}
+
+VALUE cIGraph_adj_e(VALUE self, VALUE v, VALUE mode){
+
+  return Qnil;
+
+}
+
+VALUE cIGraph_nonadj_e(VALUE self, VALUE v, VALUE mode){
+
+  return Qnil;
+
+}
+

data/ext/cIGraph_shortest_paths.c

@@ -0,0 +1,112 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+VALUE cIGraph_shortest_paths(VALUE self, VALUE from, VALUE mode){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_matrix_t res;
+  int i;
+  int j;
+  VALUE row;
+  VALUE path_length;
+  VALUE matrix = rb_ary_new();
+  int n_row;
+  int n_col;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  n_row = NUM2INT(rb_funcall(from,rb_intern("length"),0));
+  n_col = igraph_vcount(graph);
+
+  //matrix to hold the results of the calculations
+  igraph_matrix_init(&res,n_row,n_col);
+
+  //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_shortest_paths(graph,&res,vids,pmode);
+
+  for(i=0; i<igraph_matrix_nrow(&res); i++){
+    row = rb_ary_new();
+    rb_ary_push(matrix,row);
+    for(j=0; j<igraph_matrix_ncol(&res); j++){
+      path_length = MATRIX(res,i,j) == n_col ? Qnil : INT2NUM(MATRIX(res,i,j));
+      rb_ary_push(row,path_length);
+    }
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_matrix_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return matrix;
+
+}
+
+VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
+
+  igraph_t *graph;
+
+  igraph_integer_t from_vid;
+  igraph_vs_t to_vids;
+  igraph_vector_t to_vidv;
+
+  igraph_neimode_t pmode = NUM2INT(mode);
+
+  igraph_vector_ptr_t res;
+  igraph_vector_t *path_v;
+
+  int i;
+  int j;
+  VALUE path;
+  VALUE matrix = rb_ary_new();
+  int n_paths;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  n_paths = NUM2INT(rb_funcall(to,rb_intern("length"),0));
+
+  //vector to hold the results of the calculations
+  igraph_vector_ptr_init(&res,0);
+  for(i=0;i<n_paths;i++){
+    path_v = malloc(sizeof(igraph_vector_t));
+    igraph_vector_init(path_v,0);
+    igraph_vector_ptr_push_back(&res,path_v);
+  }
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,to,&to_vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&to_vids,&to_vidv);
+
+  //The id of the vertex from where we are counting
+  from_vid = cIGraph_get_vertex_id(self, from);
+
+  igraph_get_shortest_paths(graph,&res,from_vid,to_vids,pmode);
+
+  for(i=0; i<n_paths; i++){
+    path = rb_ary_new();
+    rb_ary_push(matrix,path);
+    for(j=0; j<igraph_vector_size(VECTOR(res)[i]); j++){
+      path_v = VECTOR(res)[i];
+      rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(*path_v)[j]));
+    }
+  }
+
+  for(i=0;i<n_paths;i++){
+    igraph_vector_destroy(VECTOR(res)[i]);
+  }
+
+  igraph_vector_destroy(&to_vidv);
+  igraph_vector_ptr_destroy(&res);
+  igraph_vs_destroy(&to_vids);
+
+  return matrix;
+
+}

data/ext/cIGraph_utility.c

@@ -0,0 +1,56 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+igraph_integer_t cIGraph_get_vertex_id(VALUE graph, VALUE v){
+
+  VALUE vertex_h;
+
+  vertex_h = rb_iv_get(graph,"@object_ids");
+
+  if(rb_funcall(vertex_h,rb_intern("has_key?"),1,v))
+    return NUM2INT(rb_hash_aref(vertex_h,v));
+
+  return -1;
+
+}
+
+VALUE cIGraph_get_vertex_object(VALUE graph, igraph_integer_t n){
+
+  VALUE vertex_h;
+
+  vertex_h = rb_iv_get(graph,"@id_objects");
+
+  if(rb_funcall(vertex_h,rb_intern("has_key?"),1,INT2NUM(n)))
+    return rb_hash_aref(vertex_h,INT2NUM(n));
+
+  return Qnil;
+
+}
+
+int cIGraph_vertex_arr_to_id_vec(VALUE graph, VALUE va, igraph_vector_t *nv){
+
+  VALUE vertex;
+  VALUE tmp;
+
+  tmp = rb_check_array_type(va);
+
+  if(NIL_P(tmp))
+    rb_raise(cIGraphError, "Array expected\n");
+    
+  //Initialize edge vector
+  igraph_vector_init_int(nv,0);
+  vertex = rb_ary_shift(va);
+  while(vertex != Qnil){
+    igraph_vector_push_back(nv,cIGraph_get_vertex_id(graph, vertex));
+    vertex = rb_ary_shift(va);
+  }
+
+  return 0;
+
+}
+
+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);
+}

data/ext/extconf.rb

@@ -0,0 +1,12 @@
+require 'mkmf'
+dir_config('igraph')
+unless have_library("igraph")
+  $stderr.puts "\nERROR: Cannot find the iGraph library, aborting."
+  exit 1
+end
+unless have_header("igraph.h")
+  $stderr.puts "\nERROR: Cannot find the iGraph header, aborting."
+  exit 1
+end
+  
+create_makefile("igraph")

data/test/tc_add_delete.rb

@@ -0,0 +1,49 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+   def test_add_edges
+    graph = IGraph.new(['A','B','C','D'],true)
+    graph.add_edges(['A','C'])
+    assert_equal [2], graph.degree(['A'],IGraph::ALL,true)
+  end
+
+  def test_add_vertices
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_equal 4, graph.vcount
+    graph.add_vertices(['E','F','G','H'])
+    assert_equal 8, graph.vcount
+    assert_equal [0], graph.degree(['E'],IGraph::ALL,true)
+    assert_nothing_raised do 
+      graph.add_vertices(['H','I'])
+    end
+    assert_equal 9, graph.vcount    
+  end
+
+  def test_add_to_empty_graph
+    graph = IGraph.new([],true)
+    assert_equal 0, graph.vcount
+    graph.add_vertices(['A','B'])
+    assert_equal 2, graph.vcount
+    graph.add_edges(['A','B'])
+    assert_equal 1, graph.ecount
+  end
+
+  def test_add_edge
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_nothing_raised do 
+      graph.add_edge('A','D')
+    end
+    assert_equal [2], graph.degree(['A'],IGraph::ALL,true)
+  end
+
+  def test_add_vertex
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_nothing_raised do 
+      graph.add_vertex('E')
+    end
+    assert_equal 5, graph.vcount
+    assert_equal [0], graph.degree(['E'],IGraph::ALL,true)
+  end
+
+end

data/test/tc_basic_properties.rb

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

data/test/tc_basic_query.rb

@@ -0,0 +1,54 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+   def test_graph_size
+    assert_equal 4, IGraph.new([1,2,3,4],true).vcount
+    assert_equal 2, IGraph.new([1,2,3,4],true).ecount
+  end
+
+  def test_eid_get_edge
+    assert_nothing_raised do 
+      IGraph.new(['A','B','C','D'],true).get_eid('A','B')
+    end
+    graph = IGraph.new(['A','B','C','D'],true)
+    eid1  = graph.get_eid('A','B')
+    eid2  = graph.get_eid('C','D') 
+    assert_equal ['A','B'], graph.edge(eid1)
+    assert_equal ['C','D'], graph.edge(eid2);
+    assert_not_equal eid1,eid2
+  end
+
+  def test_neighbours
+    assert_nothing_raised do
+      IGraph.new(['A','B','C','D'],true).neighbors('A',IGraph::ALL)
+    end
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_equal ['B'], graph.neighbors('A',IGraph::ALL)
+    assert_equal ['D'], graph.neighbors('C',IGraph::ALL)    
+  end
+
+  def test_adjacent
+    assert_nothing_raised do
+      IGraph.new(['A','B','C','D'],true).adjacent('A',IGraph::ALL)
+    end
+    graph = IGraph.new(['A','B','C','D'],true)
+    eid1  = graph.get_eid('A','B')
+    eid2  = graph.adjacent('A',IGraph::ALL)[0]
+    assert_equal eid1, eid2
+  end
+
+  def test_directed
+    assert IGraph.new(['A','B','C','D'],true).is_directed?
+    assert !(IGraph.new(['A','B','C','D'],false).is_directed?)
+  end
+
+  def test_degree
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_equal [1],  graph.degree(['A'],    IGraph::ALL,true)
+    assert_equal [1,1],graph.degree(['A','B'],IGraph::ALL,true)
+    assert_raises IGraphError do 
+      graph.degree('A',IGraph::ALL,true)
+    end
+  end
+end

data/test/tc_create.rb

@@ -0,0 +1,11 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+
+  def test_graph
+    assert_nothing_raised{IGraph.new([],true)}
+    assert_nothing_raised{IGraph.new(['A','B','C','D'],true)}
+  end
+
+end

data/test/tc_error_handling.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_edge_fail
+    assert_raise IGraphError do
+      IGraph.new([1,2,3],true)
+    end
+  end
+end

data/test/tc_iterators.rb

@@ -0,0 +1,44 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_each_vertex
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_nothing_raised do
+      graph.each_vertex do |v|
+      end
+    end
+    assert_nothing_raised do
+      graph.each do |v|
+      end
+    end
+  end
+
+  def test_each_edge
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert_nothing_raised do
+      graph.each_edge(IGraph::EDGEORDER_ID) do |v,w|
+      end
+    end
+    assert_nothing_raised do
+      graph.each_edge_eid(IGraph::EDGEORDER_ID) do |v|
+      end
+    end   
+    edges = []
+    graph.each_edge(IGraph::EDGEORDER_ID){|v,w| edges.push([v,w])}
+    assert_equal [['A','B'],['C','D']], edges
+    edges = []
+    graph.each_edge_eid(IGraph::EDGEORDER_ID){|v| edges.push(v)}
+    assert_equal [0,1], edges    
+  end
+
+  def test_enumerable
+    graph = IGraph.new(['A','B','C','D'],true)
+    assert graph.all?{|v| v.kind_of? String}
+    assert graph.any?{|v| v == 'B'}
+    assert_equal ['A','B','C','D'], graph.collect{|v| v}
+    assert graph.detect(Proc.new{true}){|v| }
+    assert_equal ['A'], graph.find_all{|v| v  < 'B'}
+  end
+
+end