igraph 0.3.1 → 0.3.2

data/History.txt

@@ -1,3 +1,11 @@
+= 0.3.2 2007-09-03
+
+* All 'structural property' functions now complete.
+
+= 0.3.1 2007-08-31
+
+* New functions added
+
 = 0.3 2007-08-16
 
 * Over-hauled attribute code

data/Manifest.txt

@@ -19,6 +19,7 @@ ext/cIGraph_kcores.c
 ext/cIGraph_layout.c
 ext/cIGraph_matrix.c
 ext/cIGraph_operators.c
+ext/cIGraph_other_ops.c
 ext/cIGraph_selectors.c
 ext/cIGraph_shortest_paths.c
 ext/cIGraph_spanning.c
@@ -43,6 +44,7 @@ test/tc_file_read_write.rb
 test/tc_iterators.rb
 test/tc_layout.rb
 test/tc_matrix.rb
+test/tc_other_ops.rb
 test/tc_selectors.rb
 test/tc_shortest_paths.rb
 test/tc_spanning.rb

data/ext/cIGraph.c

@@ -184,7 +184,7 @@ void Init_igraph(){
 
   rb_include_module(cIGraph, rb_mEnumerable);
 
-  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.3.1"));
+  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.3.2"));
 
   rb_define_const(cIGraph, "EDGEORDER_ID",   INT2NUM(1));
   rb_define_const(cIGraph, "EDGEORDER_FROM", INT2NUM(2));
@@ -203,6 +203,10 @@ void Init_igraph(){
   rb_define_const(cIGraph, "EACH",      INT2NUM(0));
   rb_define_const(cIGraph, "COLLAPSE",  INT2NUM(1));
 
+  rb_define_const(cIGraph, "GET_ADJACENCY_UPPER", INT2NUM(0));
+  rb_define_const(cIGraph, "GET_ADJACENCY_LOWER", INT2NUM(1));
+  rb_define_const(cIGraph, "GET_ADJACENCY_BOTH",  INT2NUM(2));  
+
   rb_define_method(cIGraph, "[]",            cIGraph_get_edge_attr, 2); /* in cIGraph_attribute_handler.c */
   rb_define_method(cIGraph, "[]=",           cIGraph_set_edge_attr, 3); /* in cIGraph_attribute_handler.c */
   rb_define_alias (cIGraph, "get_edge_attr", "[]");
@@ -285,6 +289,13 @@ void Init_igraph(){
 
   rb_define_method(cIGraph, "coreness", cIGraph_coreness, 1); /* in cIGraph_kcores.c */
 
+  rb_define_method(cIGraph, "density",       cIGraph_density,       1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph, "simplify",      cIGraph_simplify,      2); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph, "reciprocity",   cIGraph_reciprocity,   1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph, "bibcoupling",   cIGraph_bibcoupling,   1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph, "cocitation",    cIGraph_cocitation,    1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph, "get_adjacency", cIGraph_get_adjacency, 1); /* in cIGraph_other_ops.c */
+  
   rb_define_method(cIGraph, "topological_sorting", cIGraph_topological_sorting, 1); /* in cIGraph_topological_sort.c */
 
   rb_define_singleton_method(cIGraph, "read_graph_edgelist", cIGraph_read_graph_edgelist, 2); /* in cIGraph_file.c */

data/ext/cIGraph.h

@@ -122,6 +122,14 @@ VALUE cIGraph_coreness(VALUE self, VALUE mode);
 //Topological sorting
 VALUE cIGraph_topological_sorting(VALUE self, VALUE mode);
 
+//Other operations
+VALUE cIGraph_density      (VALUE self, VALUE loops);
+VALUE cIGraph_simplify     (VALUE self, VALUE mult, VALUE loops);
+VALUE cIGraph_reciprocity  (VALUE self, VALUE loops);
+VALUE cIGraph_bibcoupling  (VALUE self, VALUE vs);
+VALUE cIGraph_cocitation   (VALUE self, VALUE vs);
+VALUE cIGraph_get_adjacency(VALUE self, VALUE mode);
+
 //File handling
 VALUE cIGraph_read_graph_edgelist (VALUE self, VALUE file, VALUE mode);
 VALUE cIGraph_write_graph_edgelist(VALUE self, VALUE file);

data/ext/cIGraph_other_ops.c

@@ -0,0 +1,249 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.density(loops) -> Float
+ *
+ * Calculate the density of a graph.
+ *
+ * The density of a graph is simply the ratio number of edges and the number 
+ * of possible edges. Note that density is ill-defined for graphs with 
+ * multiple and/or loop edges, so consider calling IGraph#simplify() on the 
+ * graph if you know that it contains multiple or loop edges. 
+ *
+ */
+
+VALUE cIGraph_density(VALUE self, VALUE loops){
+
+  igraph_t *graph;
+  igraph_bool_t l = 0;
+  igraph_real_t r;
+
+  if(loops == Qtrue)
+    l = 1;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_density(graph,&r,l);
+
+  return rb_float_new(r);
+
+}
+
+/* call-seq:
+ *   graph.simplify(multiple,loops) -> nil
+ *
+ * Removes loop and/or multiple edges from the graph.
+ * multiple: Logical, if true, multiple edges will be removed. loops: Logical,
+ * if true, loops (self edges) will be removed. 
+ *
+ */
+
+VALUE cIGraph_simplify(VALUE self, VALUE mult, VALUE loops){
+
+  igraph_t *graph;
+  igraph_bool_t l = 0;
+  igraph_bool_t m = 0;
+
+  if(loops == Qtrue)
+    l = 1;
+  if(mult == Qtrue)
+    m = 1;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_simplify(graph,m,l);
+
+  return Qnil;
+
+}
+
+/* call-seq:
+ *   graph.reciprocity(loops) -> Float
+ *
+ * Calculates the reciprocity of a directed graph.
+ *
+ * A vertex pair (A, B) is said to be reciprocal if there are edges between 
+ * them in both directions. The reciprocity of a directed graph is the 
+ * proportion of all possible (A, B) pairs which are reciprocal, provided 
+ * there is at least one edge between A and B. The reciprocity of an empty 
+ * graph is undefined (results in an error code). Undirected graphs always 
+ * have a reciprocity of 1.0 unless they are empty.  
+ *
+ */
+
+VALUE cIGraph_reciprocity(VALUE self, VALUE loops){
+
+  igraph_t *graph;
+  igraph_bool_t l = 0;
+  igraph_real_t r;
+
+  if(loops == Qtrue)
+    l = 1;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_reciprocity(graph,&r,l);
+
+  return rb_float_new(r);
+
+}
+
+/* call-seq:
+ *   graph.bibcoupling(varray) -> Array
+ *
+ * Bibliographic coupling.
+ *
+ * The bibliographic coupling of two vertices is the number of other 
+ * vertices they both cite. The 
+ * bibliographic coupling score for each given vertex and all other 
+ * vertices in the graph will be calculated.
+ *
+ */
+VALUE cIGraph_bibcoupling(VALUE self, VALUE vs){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  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(vs,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
+  igraph_vector_init_int(&vidv,0);
+  cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_bibcoupling(graph,&res,vids);
+
+  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 = 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;
+
+}
+
+/* call-seq:
+ *   graph.cocitation(varray) -> Array
+ *
+ * Cocitation coupling.
+ *
+ * Two vertices are cocited if there is another vertex citing both of them. 
+ * igraph_cocitation() simply counts how many types two vertices are cocited. 
+ * The cocitation score for each given vertex and all other vertices in the 
+ * graph will be calculated. 
+ *
+ */
+VALUE cIGraph_cocitation(VALUE self, VALUE vs){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  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(vs,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
+  igraph_vector_init_int(&vidv,0);
+  cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_cocitation(graph,&res,vids);
+
+  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 = 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;
+
+}
+
+/* call-seq:
+ *   graph.get_adjacency(type) -> Array
+ *
+ * Returns the adjacency matrix of a graph
+ *
+ */
+VALUE cIGraph_get_adjacency(VALUE self, VALUE mode){
+
+  igraph_t *graph;
+  igraph_get_adjacency_t pmode = NUM2INT(mode);
+  igraph_matrix_t res;
+  int i;
+  int j;
+  VALUE row;
+  VALUE path_length;
+  VALUE matrix = rb_ary_new();
+  int n;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  n = igraph_vcount(graph);
+
+  //matrix to hold the results of the calculations
+  igraph_matrix_init(&res,n,n);
+
+  igraph_get_adjacency(graph,&res,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 = INT2NUM(MATRIX(res,i,j));
+      rb_ary_push(row,path_length);
+    }
+  }
+
+  igraph_matrix_destroy(&res);
+
+  return matrix;
+
+}

data/test/tc_other_ops.rb

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+   def test_density
+     g = IGraph.new(['A','B','C','D'],true)
+     assert_equal 0.125, g.density(true)
+   end
+   def test_simplify
+     g = IGraph.new(['A','B','A','B','C','D','A','A'],true)
+     assert_equal 4, g.ecount
+     g.simplify(true,false)
+     assert_equal 3, g.ecount
+     g.simplify(true,true)
+     assert_equal 2, g.ecount
+   end
+   def test_reciprocity
+     g = IGraph.new(['A','B','C','D','B','A'],true)
+     assert_equal 0.5, g.reciprocity(true)
+   end
+   def test_bibcoupling
+     g = IGraph.new(['A','B','C','D','D','B'],true)
+     assert_equal [[0,0,0,1]], g.bibcoupling(['A'])     
+   end
+   def test_cocitation
+     g = IGraph.new(['A','B','C','D','A','D'],true)
+     assert_equal [[0,0,0,1]], g.cocitation(['B'])     
+   end
+   def test_get_adjacency
+     g = IGraph.new(['A','B','C','D'],true)
+     assert_equal [[0,1,0,0],[0,0,0,0],[0,0,0,1],[0,0,0,0]], g.get_adjacency(1)
+   end
+ end
+ 

data/test/test_all.rb

@@ -18,6 +18,7 @@ require 'tc_error_handling'
 require 'tc_file_read_write'
 require 'tc_layout'
 require 'tc_matrix'
+require 'tc_other_ops'
 require 'tc_shortest_paths'
 require 'tc_spanning'
 require 'tc_spectral'

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: igraph
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
-date: 2007-08-31 00:00:00 +09:00
+  version: 0.3.2
+date: 2007-09-03 00:00:00 +09:00
 summary: IGraph is a Ruby extension for interfacing with the C igraph library (http://cneurocvs.rmki.kfki.hu/igraph/). igraph is a library for creating and manipulating graphs with a particular emphasis on network analysis functions.
 require_paths: 
 - test
@@ -50,6 +50,7 @@ files:
 - ext/cIGraph_layout.c
 - ext/cIGraph_matrix.c
 - ext/cIGraph_operators.c
+- ext/cIGraph_other_ops.c
 - ext/cIGraph_selectors.c
 - ext/cIGraph_shortest_paths.c
 - ext/cIGraph_spanning.c
@@ -74,6 +75,7 @@ files:
 - test/tc_iterators.rb
 - test/tc_layout.rb
 - test/tc_matrix.rb
+- test/tc_other_ops.rb
 - test/tc_selectors.rb
 - test/tc_shortest_paths.rb
 - test/tc_spanning.rb