igraph 0.3 → 0.3.1

data/Manifest.txt

@@ -2,6 +2,7 @@ History.txt
 License.txt
 Manifest.txt
 README.txt
+Rakefile.rb
 ext/cIGraph.c
 ext/cIGraph.h
 ext/cIGraph_add_delete.c
@@ -10,17 +11,23 @@ ext/cIGraph_basic_properties.c
 ext/cIGraph_basic_query.c
 ext/cIGraph_centrality.c
 ext/cIGraph_components.c
+ext/cIGraph_direction.c
 ext/cIGraph_error_handlers.c
 ext/cIGraph_file.c
 ext/cIGraph_iterators.c
+ext/cIGraph_kcores.c
 ext/cIGraph_layout.c
 ext/cIGraph_matrix.c
 ext/cIGraph_operators.c
 ext/cIGraph_selectors.c
 ext/cIGraph_shortest_paths.c
+ext/cIGraph_spanning.c
+ext/cIGraph_spectral.c
 ext/cIGraph_topological_sort.c
+ext/cIGraph_transitivity.c
 ext/cIGraph_utility.c
 ext/cIGraph_vertex_neighbourhood.c
+ext/extconf.rb
 test/tc_add_delete.rb
 test/tc_attributes.rb
 test/tc_basic_properties.rb
@@ -28,7 +35,9 @@ test/tc_basic_query.rb
 test/tc_centrality.rb
 test/tc_components.rb
 test/tc_copy.rb
+test/tc_cores.rb
 test/tc_create.rb
+test/tc_directedness.rb
 test/tc_error_handling.rb
 test/tc_file_read_write.rb
 test/tc_iterators.rb
@@ -36,6 +45,10 @@ test/tc_layout.rb
 test/tc_matrix.rb
 test/tc_selectors.rb
 test/tc_shortest_paths.rb
+test/tc_spanning.rb
+test/tc_spectral.rb
+test/tc_thrash.rb
 test/tc_topological_sort.rb
+test/tc_transitivity.rb
 test/tc_vertex_neighbourhood.rb
 test/test_all.rb

data/Rakefile.rb

@@ -0,0 +1,52 @@
+require 'hoe'
+
+$LOAD_PATH.unshift("./ext")
+
+class IGraph
+  VERSION = "0.0"
+end
+
+begin 
+  require 'igraph'
+rescue RuntimeError
+end
+
+hoe = Hoe.new("igraph",IGraph::VERSION) do |p|
+  
+  p.author = "Alex Gutteridge"
+  p.email = "alexg@kuicr.kyoto-u.ac.jp"
+  p.url = "http://igraph.rubyforge.org/"
+  
+  p.description = p.paragraphs_of("README.txt",1..3)[0]
+  p.summary     = p.paragraphs_of("README.txt",1)[0]
+  p.changes     = p.paragraphs_of("History.txt",0..1).join("\n\n")
+  
+  p.clean_globs = ["ext/*.o","ext/*.so","ext/Makefile","ext/mkmf.log","**/*~","email.txt","manual.{aux,log,out,toc,pdf}"]
+  
+  p.rdoc_pattern = /(^ext\/.*\.c$|^README|^History|^License)/
+  
+  p.spec_extras = {
+    :extensions    => ['ext/extconf.rb'],
+    :require_paths => ['test'],
+    :has_rdoc      => true,
+    :extra_rdoc_files => ["README.txt","History.txt","License.txt"],
+    :rdoc_options  => ["--exclude", "test/*", "--main", "README.txt", "--inline-source"]
+  }
+
+end
+  
+hoe.spec.dependencies.delete_if{|dep| dep.name == "hoe"}
+
+IGRAPH = '/usr/local/include/igraph'
+
+desc "Uses extconf.rb and make to build the extension"
+task :build_extension => ['ext/igraph.so']
+SRC = FileList['ext/*.c'] + FileList['ext/*.h']
+file 'ext/igraph.so' => SRC do
+  Dir.chdir('ext')
+  system("ruby extconf.rb --with-igraph-include=#{IGRAPH}")
+  system("make")
+  Dir.chdir('..')
+end
+
+task :test => [:build_extension]

data/ext/cIGraph.c

@@ -8,6 +8,7 @@ VALUE cIGraphError;
 
 void cIGraph_free(void *p){
   igraph_destroy(p);
+  free(p);
 }
 
 void cIGraph_mark(void *p){
@@ -48,7 +49,7 @@ VALUE cIGraph_init_copy(VALUE copy, VALUE orig){
   Data_Get_Struct(copy, igraph_t, copy_graph); 
   Data_Get_Struct(orig, igraph_t, orig_graph);
 
-  igraph_copy(copy_graph,orig_graph);
+  IGRAPH_CHECK(igraph_copy(copy_graph,orig_graph));
 
   return copy;
 
@@ -103,17 +104,21 @@ VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){
   rb_scan_args(argc,argv,"12", &edges, &directed, &attrs);
 
   //Initialize edge vector
-  igraph_vector_init_int(&edge_v,0);
+  IGRAPH_FINALLY(igraph_vector_destroy,&edge_v);
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&vertex_attr);
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&edge_attr);
 
-  igraph_vector_ptr_init(&vertex_attr,0);
-  igraph_vector_ptr_init(&edge_attr,0);
+  IGRAPH_CHECK(igraph_vector_init_int(&edge_v,0));
+
+  IGRAPH_CHECK(igraph_vector_ptr_init(&vertex_attr,0));
+  IGRAPH_CHECK(igraph_vector_ptr_init(&edge_attr,0));
 
   Data_Get_Struct(self, igraph_t, graph);
 
   v_ary = rb_ary_new();
 
   if(!directed)
-    igraph_to_undirected(graph,IGRAPH_TO_UNDIRECTED_COLLAPSE);
+    IGRAPH_CHECK(igraph_to_undirected(graph,IGRAPH_TO_UNDIRECTED_COLLAPSE));
 
   //Loop through objects in edge Array
   for (i=0; i<RARRAY(edges)->len; i++) {
@@ -131,7 +136,7 @@ VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){
       rb_ary_push((VALUE)v_attr_rec.value,vertex);
       
     }
-    igraph_vector_push_back(&edge_v,current_vertex_id);
+    IGRAPH_CHECK(igraph_vector_push_back(&edge_v,current_vertex_id));
     if (i % 2){
       if (attrs != Qnil){
 	rb_ary_push((VALUE)e_attr_rec.value,RARRAY(attrs)->ptr[i/2]);
@@ -141,18 +146,20 @@ VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){
     }
   }
 
-  igraph_vector_ptr_push_back(&vertex_attr, &v_attr_rec);
-  igraph_vector_ptr_push_back(&edge_attr,   &e_attr_rec);
+  IGRAPH_CHECK(igraph_vector_ptr_push_back(&vertex_attr, &v_attr_rec));
+  IGRAPH_CHECK(igraph_vector_ptr_push_back(&edge_attr,   &e_attr_rec));
 
   if(igraph_vector_size(&edge_v) > 0){
-    igraph_add_vertices(graph,vertex_n,&vertex_attr);
-    igraph_add_edges(graph,&edge_v,&edge_attr);
+    IGRAPH_CHECK(igraph_add_vertices(graph,vertex_n,&vertex_attr));
+    IGRAPH_CHECK(igraph_add_edges(graph,&edge_v,&edge_attr));
   }
 
   igraph_vector_destroy(&edge_v);
   igraph_vector_ptr_destroy(&vertex_attr);
   igraph_vector_ptr_destroy(&edge_attr);
 
+  IGRAPH_FINALLY_CLEAN(3);
+
   return self;
 
 }
@@ -177,7 +184,7 @@ void Init_igraph(){
 
   rb_include_module(cIGraph, rb_mEnumerable);
 
-  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.3"));
+  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.3.1"));
 
   rb_define_const(cIGraph, "EDGEORDER_ID",   INT2NUM(1));
   rb_define_const(cIGraph, "EDGEORDER_FROM", INT2NUM(2));
@@ -191,6 +198,11 @@ void Init_igraph(){
   rb_define_const(cIGraph, "WEAK",   INT2NUM(1));
   rb_define_const(cIGraph, "STRONG", INT2NUM(2));  
 
+  rb_define_const(cIGraph, "ARBITRARY", INT2NUM(0));
+  rb_define_const(cIGraph, "MUTUAL",    INT2NUM(1));
+  rb_define_const(cIGraph, "EACH",      INT2NUM(0));
+  rb_define_const(cIGraph, "COLLAPSE",  INT2NUM(1));
+
   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", "[]");
@@ -259,6 +271,20 @@ void Init_igraph(){
   rb_define_method(cIGraph, "constraint",       cIGraph_constraint,      -1); /* in cIGraph_centrality.c */  
   rb_define_method(cIGraph, "maxdegree",        cIGraph_maxdegree,        3); /* in cIGraph_centrality.c */    
 
+  rb_define_method(cIGraph, "minimum_spanning_tree_unweighted", cIGraph_minimum_spanning_tree_unweighted, 0); /* in cIGraph_spanning.c */
+  rb_define_method(cIGraph, "minimum_spanning_tree_prim",       cIGraph_minimum_spanning_tree_prim,       1); /* in cIGraph_spanning.c */
+
+  rb_define_method(cIGraph, "transitivity",          cIGraph_transitivity,          0); /* in cIGraph_transitivity.c */
+  rb_define_method(cIGraph, "transitivity_local",    cIGraph_transitivity_local,    1); /* in cIGraph_transitivity.c */
+  rb_define_method(cIGraph, "transitivity_avglocal", cIGraph_transitivity_avglocal, 0); /* in cIGraph_transitivity.c */
+
+  rb_define_method(cIGraph, "to_directed",   cIGraph_to_directed,   1); /* in cIGraph_direction.c */
+  rb_define_method(cIGraph, "to_undirected", cIGraph_to_undirected, 1); /* in cIGraph_direction.c */  
+
+  rb_define_method(cIGraph, "laplacian", cIGraph_laplacian, 1); /* in cIGraph_spectral.c */
+
+  rb_define_method(cIGraph, "coreness", cIGraph_coreness, 1); /* in cIGraph_kcores.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

@@ -100,6 +100,25 @@ VALUE cIGraph_pagerank        (VALUE self, VALUE vs, VALUE directed, VALUE niter
 VALUE cIGraph_constraint      (int argc, VALUE *argv, VALUE self);
 VALUE cIGraph_maxdegree       (VALUE self, VALUE vs, VALUE mode, VALUE loops);
 
+//Spanning trees
+VALUE cIGraph_minimum_spanning_tree_prim      (VALUE self, VALUE weights);
+VALUE cIGraph_minimum_spanning_tree_unweighted(VALUE self);
+
+//Transitivity
+VALUE cIGraph_transitivity         (VALUE self);
+VALUE cIGraph_transitivity_local   (VALUE self, VALUE vs);
+VALUE cIGraph_transitivity_avglocal(VALUE self);
+
+//Directedness conversion
+VALUE cIGraph_to_directed  (VALUE self, VALUE mode);
+VALUE cIGraph_to_undirected(VALUE self, VALUE mode);
+
+//Spectral properties
+VALUE cIGraph_laplacian(VALUE self, VALUE mode);
+
+//K-Cores
+VALUE cIGraph_coreness(VALUE self, VALUE mode);
+
 //Topological sorting
 VALUE cIGraph_topological_sorting(VALUE self, VALUE mode);
 

data/ext/cIGraph_add_delete.c

@@ -40,8 +40,10 @@ VALUE cIGraph_add_edges(int argc, VALUE *argv, VALUE self){
   rb_scan_args(argc, argv, "11", &edges, &attrs);
 
   //Initialize edge vector
-  igraph_vector_init_int(&edge_v,0);
-  igraph_vector_ptr_init(&edge_attr,0);
+  IGRAPH_FINALLY(igraph_vector_destroy,&edge_v);
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&edge_attr);
+  IGRAPH_CHECK(igraph_vector_init_int(&edge_v,0));
+  IGRAPH_CHECK(igraph_vector_ptr_init(&edge_attr,0));
 
   Data_Get_Struct(self, igraph_t, graph);
 
@@ -55,7 +57,7 @@ VALUE cIGraph_add_edges(int argc, VALUE *argv, VALUE self){
     } else {
       rb_raise(cIGraphError, "Unknown vertex in edge array. Use add_vertices first");
     }
-    igraph_vector_push_back(&edge_v,vid);
+    IGRAPH_CHECK(igraph_vector_push_back(&edge_v,vid));
     if (i % 2){
       if (attrs != Qnil){
 	rb_ary_push((VALUE)e_attr_rec.value,RARRAY(attrs)->ptr[i/2]);
@@ -65,15 +67,17 @@ VALUE cIGraph_add_edges(int argc, VALUE *argv, VALUE self){
     }
   }
 
-  igraph_vector_ptr_push_back(&edge_attr, &e_attr_rec);
+  IGRAPH_CHECK(igraph_vector_ptr_push_back(&edge_attr, &e_attr_rec));
 
   if(igraph_vector_size(&edge_v) > 0){
-    code = igraph_add_edges(graph,&edge_v,&edge_attr);
+    IGRAPH_CHECK(code = igraph_add_edges(graph,&edge_v,&edge_attr));
   }
 
   igraph_vector_destroy(&edge_v);
   igraph_vector_ptr_destroy(&edge_attr);
 
+  IGRAPH_FINALLY_CLEAN(2);
+
   return INT2NUM(code);
 
 }
@@ -108,7 +112,8 @@ VALUE cIGraph_add_vertices(VALUE self, VALUE vs){
   v_attr_rec.type  = IGRAPH_ATTRIBUTE_PY_OBJECT;
   v_attr_rec.value = (void*)rb_ary_new();
 
-  igraph_vector_ptr_init(&vertex_attr,0);
+  IGRAPH_CHECK(igraph_vector_ptr_init(&vertex_attr,0));
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&vertex_attr);
 
   Data_Get_Struct(self, igraph_t, graph);
   v_ary = ((VALUE*)graph->attr)[0];
@@ -127,9 +132,12 @@ VALUE cIGraph_add_vertices(VALUE self, VALUE vs){
     }
   }
 
-  igraph_vector_ptr_push_back(&vertex_attr,&v_attr_rec);
+  IGRAPH_CHECK(igraph_vector_ptr_push_back(&vertex_attr,&v_attr_rec));
+
+  IGRAPH_CHECK(code = igraph_add_vertices(graph,to_add,&vertex_attr));
 
-  code = igraph_add_vertices(graph,to_add,&vertex_attr);
+  igraph_vector_ptr_destroy(&vertex_attr);
+  IGRAPH_FINALLY_CLEAN(1);
 
   return INT2NUM(code);
 
@@ -172,8 +180,10 @@ VALUE cIGraph_add_edge(int argc, VALUE *argv, VALUE self){
   rb_scan_args(argc, argv, "21", &from, &to, &attr);
 
   //Initialize edge vector
-  igraph_vector_init_int(&edge_v,0);
-  igraph_vector_ptr_init(&edge_attr,0);
+  IGRAPH_FINALLY(igraph_vector_destroy,&edge_v);
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&edge_attr);
+  IGRAPH_CHECK(igraph_vector_init_int(&edge_v,0));
+  IGRAPH_CHECK(igraph_vector_ptr_init(&edge_attr,0));
 
   Data_Get_Struct(self, igraph_t, graph);
 
@@ -181,20 +191,21 @@ VALUE cIGraph_add_edge(int argc, VALUE *argv, VALUE self){
 
   if(rb_ary_includes(v_ary,from) && rb_ary_includes(v_ary,to)){
     //If graph includes this vertex then look up the vertex number
-    igraph_vector_push_back(&edge_v,cIGraph_get_vertex_id(self, from));
-    igraph_vector_push_back(&edge_v,cIGraph_get_vertex_id(self, to));
+    IGRAPH_CHECK(igraph_vector_push_back(&edge_v,cIGraph_get_vertex_id(self, from)));
+    IGRAPH_CHECK(igraph_vector_push_back(&edge_v,cIGraph_get_vertex_id(self, to)));
     rb_ary_push((VALUE)e_attr_rec.value,attr);
   } else {
     rb_raise(cIGraphError, "Unknown vertex in edge array. Use add_vertices");
   }
 
-  igraph_vector_ptr_push_back(&edge_attr,&e_attr_rec);
-
-  code = igraph_add_edges(graph,&edge_v,&edge_attr);
+  IGRAPH_CHECK(igraph_vector_ptr_push_back(&edge_attr,&e_attr_rec));
+  IGRAPH_CHECK(code = igraph_add_edges(graph,&edge_v,&edge_attr));
 
   igraph_vector_ptr_destroy(&edge_attr);
   igraph_vector_destroy(&edge_v);
 
+  IGRAPH_FINALLY_CLEAN(2);
+
   return INT2NUM(code);
 
 }
@@ -229,23 +240,28 @@ VALUE cIGraph_add_vertex(VALUE self, VALUE v){
   v_attr_rec.type  = IGRAPH_ATTRIBUTE_PY_OBJECT;
   v_attr_rec.value = (void*)rb_ary_new();
 
-  igraph_vector_ptr_init(&vertex_attr,0);
+  IGRAPH_CHECK(igraph_vector_ptr_init(&vertex_attr,0));
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&vertex_attr);
 
   Data_Get_Struct(self, igraph_t, graph);
 
   v_ary = ((VALUE*)graph->attr)[0];
-  
+
   //Loop through objects in vertex array
   if(rb_ary_includes(v_ary,v)){
     //rb_raise(cIGraphError, "Vertex already added to graph");
+    igraph_vector_ptr_destroy(&vertex_attr);
+    IGRAPH_FINALLY_CLEAN(1);     
     return code;
   } else {
     rb_ary_push((VALUE)v_attr_rec.value,v);
   }
 
-  igraph_vector_ptr_push_back(&vertex_attr,&v_attr_rec);
+  IGRAPH_CHECK(igraph_vector_ptr_push_back(&vertex_attr,&v_attr_rec));
+  IGRAPH_CHECK(code = igraph_add_vertices(graph,1,&vertex_attr));
 
-  code = igraph_add_vertices(graph,1,&vertex_attr);
+  igraph_vector_ptr_destroy(&vertex_attr);
+  IGRAPH_FINALLY_CLEAN(1); 
 
   return INT2NUM(code);
 

data/ext/cIGraph_attribute_handler.c

@@ -90,7 +90,7 @@ int cIGraph_attribute_init(igraph_t *graph, igraph_vector_ptr_t *attr) {
   VALUE key;
   VALUE value;
 
-  attrs = ALLOC_N(VALUE, 3);
+  attrs = (VALUE*)calloc(3, sizeof(VALUE));
 
   if(!attrs)
     IGRAPH_ERROR("Error allocating Arrays\n", IGRAPH_ENOMEM);
@@ -132,7 +132,8 @@ int cIGraph_attribute_init(igraph_t *graph, igraph_vector_ptr_t *attr) {
 
 /* Destruction */
 void cIGraph_attribute_destroy(igraph_t *graph) {
-  free(graph->attr);
+  VALUE *attrs = (VALUE*)graph->attr;
+  free(attrs);
   return;
 }
 

data/ext/cIGraph_basic_query.c

@@ -85,10 +85,11 @@ VALUE cIGraph_edge(VALUE self, VALUE eid){
  *
  */
 VALUE cIGraph_get_eid(VALUE self, VALUE from, VALUE to, VALUE directed){
+
     igraph_t *graph;
     igraph_integer_t eid = 0;
-    int from_i;
-    int to_i;
+    int from_i = 0;
+    int to_i = 0;
     igraph_bool_t directed_b = 0;
 
     Data_Get_Struct(self, igraph_t, graph);
@@ -241,6 +242,7 @@ VALUE cIGraph_degree(VALUE self, VALUE v, VALUE mode, VALUE loops){
   Data_Get_Struct(self, igraph_t, graph);
 
   //Convert an array of vertices to a vector of vertex ids
+  igraph_vector_init_int(&vidv,0);
   cIGraph_vertex_arr_to_id_vec(self,v,&vidv);
   //create vertex selector from the vecotr of ids
   igraph_vs_vector(&vids,&vidv);

data/ext/cIGraph_centrality.c

@@ -25,6 +25,7 @@ VALUE cIGraph_closeness(VALUE self, VALUE vs, VALUE mode){
   Data_Get_Struct(self, igraph_t, graph);
 
   //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);
@@ -64,25 +65,32 @@ VALUE cIGraph_betweenness(VALUE self, VALUE vs, VALUE directed){
     dir = 1;
 
   //vector to hold the results of the degree calculations
-  igraph_vector_init_int(&res,0);
+  IGRAPH_FINALLY(igraph_vector_destroy, &res);
+  IGRAPH_FINALLY(igraph_vector_destroy, &vidv);
+  IGRAPH_FINALLY(igraph_vs_destroy,&vids);
+   
+  IGRAPH_CHECK(igraph_vector_init(&res,0));
 
   Data_Get_Struct(self, igraph_t, graph);
 
   //Convert an array of vertices to a vector of vertex ids
+  IGRAPH_CHECK(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_CHECK(igraph_vs_vector(&vids,&vidv));
 
-  igraph_betweenness(graph,&res,vids,dir);
+  IGRAPH_CHECK(igraph_betweenness(graph,&res,vids,dir));
 
   for(i=0;i<igraph_vector_size(&res);i++){
-    rb_ary_push(betweenness,INT2NUM((int)VECTOR(res)[i]));
+    rb_ary_push(betweenness,rb_float_new((float)VECTOR(res)[i]));
   }
 
   igraph_vector_destroy(&vidv);
   igraph_vector_destroy(&res);
   igraph_vs_destroy(&vids);
 
+  IGRAPH_FINALLY_CLEAN(3);
+
   return betweenness;
 
 }
@@ -148,6 +156,7 @@ VALUE cIGraph_pagerank(VALUE self, VALUE vs, VALUE directed, VALUE niter, VALUE
   Data_Get_Struct(self, igraph_t, graph);
 
   //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);
@@ -179,7 +188,7 @@ VALUE cIGraph_constraint(int argc, VALUE *argv, VALUE self){
   igraph_vs_t vids;
   igraph_vector_t vidv;
   igraph_vector_t res;
-  igraph_vector_t *wght =  malloc(sizeof(igraph_vector_t));
+  igraph_vector_t wght;
   int i;
   VALUE constraints = rb_ary_new();
   VALUE vs, weights;
@@ -187,38 +196,39 @@ VALUE cIGraph_constraint(int argc, VALUE *argv, VALUE self){
   rb_scan_args(argc,argv,"11",&vs, &weights);
 
   //vector to hold the results of the degree calculations
-  igraph_vector_init(&res,0);
-  igraph_vector_init(wght,0);
+  IGRAPH_FINALLY(igraph_vector_destroy, &res);
+  IGRAPH_FINALLY(igraph_vector_destroy, &wght);
+  IGRAPH_FINALLY(igraph_vector_destroy, &vidv);
+  IGRAPH_CHECK(igraph_vector_init(&res,0));
+  IGRAPH_CHECK(igraph_vector_init(&wght,0));
 
   Data_Get_Struct(self, igraph_t, graph);
 
   //Convert an array of vertices to a vector of vertex ids
+  IGRAPH_CHECK(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);
 
   if(weights == Qnil){
-    igraph_vector_destroy(wght);
-    wght = NULL;
+    IGRAPH_CHECK(igraph_constraint(graph,&res,vids,NULL));
   } else {
     for(i=0;i<RARRAY(weights)->len;i++){
-      igraph_vector_push_back(wght,NUM2DBL(RARRAY(weights)->ptr[i]));
+      IGRAPH_CHECK(igraph_vector_push_back(&wght,NUM2DBL(RARRAY(weights)->ptr[i])));
     }
+    IGRAPH_CHECK(igraph_constraint(graph,&res,vids,&wght));
   }
 
-  igraph_constraint(graph,&res,vids,wght);
-
   for(i=0;i<igraph_vector_size(&res);i++){
     rb_ary_push(constraints,rb_float_new(VECTOR(res)[i]));
   }
 
   igraph_vector_destroy(&vidv);
   igraph_vector_destroy(&res);
-  if(wght != NULL)
-    igraph_vector_destroy(wght);
+  igraph_vector_destroy(&wght);
   igraph_vs_destroy(&vids);
 
-  free(wght);
+  IGRAPH_FINALLY_CLEAN(3);
 
   return constraints;
 
@@ -250,6 +260,7 @@ VALUE cIGraph_maxdegree(VALUE self, VALUE vs, VALUE mode, VALUE loops){
   Data_Get_Struct(self, igraph_t, graph);
 
   //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);

data/ext/cIGraph_components.c

@@ -53,6 +53,7 @@ VALUE cIGraph_subgraph(VALUE self, VALUE vs){
   Data_Get_Struct(self, igraph_t, graph);
 
   //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);

data/ext/cIGraph_direction.c

@@ -0,0 +1,39 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.to_directed(mode)
+ *
+ * Converts the graph to a directed graph. 
+ */
+VALUE cIGraph_to_directed(VALUE self, VALUE mode){
+
+  igraph_t *graph;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  int ret;
+
+  Data_Get_Struct(self, igraph_t, graph);
+  IGRAPH_CHECK(ret = igraph_to_directed(graph,pmode));
+
+  return INT2NUM(ret);
+
+}
+
+/* call-seq:
+ *   graph.to_undirected(mode)
+ *
+ * Converts the graph to a directed graph. 
+ */
+VALUE cIGraph_to_undirected(VALUE self, VALUE mode){
+
+  igraph_t *graph;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  int ret;
+
+  Data_Get_Struct(self, igraph_t, graph);
+  IGRAPH_CHECK(ret = igraph_to_undirected(graph,pmode));
+
+  return INT2NUM(ret);
+
+}

data/ext/cIGraph_error_handlers.c

@@ -4,6 +4,7 @@
 
 void cIGraph_error_handler(const char *reason, const char *file,
                              int line, int igraph_errno) {
+  IGRAPH_FINALLY_FREE();
   rb_raise(cIGraphError, reason);
 }
 

data/ext/cIGraph_file.c

@@ -177,7 +177,7 @@ VALUE cIGraph_read_graph_pajek(VALUE self, VALUE file){
   string = rb_funcall(file, rb_intern("read"), 0);
   stream = fmemopen(RSTRING(string)->ptr,RSTRING(string)->len, "r");
 
-  igraph_read_graph_pajek(graph, stream);
+  IGRAPH_CHECK(igraph_read_graph_pajek(graph, stream));
 
   fclose(stream);
 

data/ext/cIGraph_kcores.c

@@ -0,0 +1,39 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.coreness(mode) -> Array
+ *
+ * Finding the coreness of the vertices in a network. The k-core of a 
+ * graph is a maximal subgraph in which each vertex has at least degree k.
+ * (Degree here means the degree in the subgraph of course.). The coreness 
+ * of a vertex is the highest order of a k-core containing the vertex.
+ *
+ * This function implements the algorithm presented in Vladimir Batagelj, 
+ * Matjaz Zaversnik: An O(m) Algorithm for Cores Decomposition of Networks. 
+ */
+VALUE cIGraph_coreness(VALUE self, VALUE mode){
+
+  igraph_t *graph;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_t cores;
+  int i;
+  VALUE result = rb_ary_new();
+  
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //vector to hold the results of the calculations
+  igraph_vector_init(&cores,0);
+
+  igraph_coreness(graph,&cores,pmode);
+
+  for(i=0; i< igraph_vector_size(&cores); i++){
+    rb_ary_push(result,VECTOR(cores)[i]);
+  }
+
+  igraph_vector_destroy(&cores);
+
+  return result;
+
+}

data/ext/cIGraph_shortest_paths.c

@@ -37,6 +37,7 @@ VALUE cIGraph_shortest_paths(VALUE self, VALUE from, VALUE mode){
   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,from,&vidv);
   //create vertex selector from the vecotr of ids
   igraph_vs_vector(&vids,&vidv);
@@ -103,6 +104,7 @@ VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
   }
 
   //Convert an array of vertices to a vector of vertex ids
+  igraph_vector_init_int(&to_vidv,0);
   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);
@@ -123,6 +125,7 @@ VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
 
   for(i=0;i<n_paths;i++){
     igraph_vector_destroy(VECTOR(res)[i]);
+    free(VECTOR(res)[i]);
   }
 
   igraph_vector_destroy(&to_vidv);
@@ -166,17 +169,19 @@ VALUE cIGraph_get_all_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mod
   Data_Get_Struct(self, igraph_t, graph);
 
   //vector to hold the results of the calculations
-  igraph_vector_ptr_init(&res,0);
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&res);
+  IGRAPH_CHECK(igraph_vector_ptr_init(&res,0));
 
   //The id of the vertex from where we are counting
   from_vid = cIGraph_get_vertex_id(self, from);
 
   //Convert an array of vertices to a vector of vertex ids
+  igraph_vector_init_int(&to_vidv,0);
   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);
+  IGRAPH_CHECK(igraph_vs_vector(&to_vids,&to_vidv));
 
-  igraph_get_all_shortest_paths(graph,&res,NULL,from_vid,to_vids,pmode);
+  IGRAPH_CHECK(igraph_get_all_shortest_paths(graph,&res,NULL,from_vid,to_vids,pmode));
 
   for(i=0; i< igraph_vector_ptr_size(&res); i++){
     path = rb_ary_new();
@@ -189,9 +194,13 @@ VALUE cIGraph_get_all_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mod
 
   for(i=0;i<igraph_vector_ptr_size(&res);i++){
     igraph_vector_destroy(VECTOR(res)[i]);
+    free(VECTOR(res)[i]);
   }
 
   igraph_vector_ptr_destroy(&res);
+  igraph_vector_destroy(&to_vidv);
+
+  IGRAPH_FINALLY_CLEAN(1);
 
   return matrix;
 
@@ -285,15 +294,17 @@ VALUE cIGraph_girth(VALUE self){
 
   igraph_t *graph;
   igraph_vector_t res;
+  igraph_integer_t girth = 0;
   int i;
   VALUE path = rb_ary_new();
 
   Data_Get_Struct(self, igraph_t, graph);
 
   //vector to hold the results of the calculations
-  igraph_vector_init(&res,0);
+  IGRAPH_FINALLY(igraph_vector_destroy,&res);
+  IGRAPH_CHECK(igraph_vector_init(&res,0));
 
-  igraph_girth(graph,NULL,&res);
+  IGRAPH_CHECK(igraph_girth(graph,&girth,&res));
 
   for(i=0; i<igraph_vector_size(&res); i++){
     rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(res)[i]));
@@ -301,6 +312,8 @@ VALUE cIGraph_girth(VALUE self){
 
   igraph_vector_destroy(&res);
 
+  IGRAPH_FINALLY_CLEAN(1);
+
   return path;
 
 }

data/ext/cIGraph_spanning.c

@@ -0,0 +1,78 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.minimum_spanning_tree_unweighted() -> IGraph
+ *
+ * Calculates one minimum spanning tree of an unweighted graph.
+ *
+ * If the graph has more minimum spanning trees (this is always the case, 
+ * except if it is a forest) this implementation returns only the same one.
+ *
+ * Directed graphs are considered as undirected for this computation.
+ *
+ * If the graph is not connected then its minimum spanning forest is returned.
+ * This is the set of the minimum spanning trees of each component. 
+ */
+VALUE cIGraph_minimum_spanning_tree_unweighted(VALUE self){
+
+  igraph_t *graph;
+  igraph_t *n_graph = malloc(sizeof(igraph_t));
+  VALUE n_graph_obj;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_minimum_spanning_tree_unweighted(graph,n_graph);
+
+  n_graph_obj = Data_Wrap_Struct(cIGraph, cIGraph_mark, cIGraph_free, n_graph);
+
+  return n_graph_obj;
+
+}
+
+/* call-seq:
+ *   graph.minimum_spanning_tree_prim(weights) -> IGraph
+ *
+ * Calculates one minimum spanning tree of a weighted graph.
+ *
+ * This function uses Prim's method for carrying out the computation, see 
+ * Prim, R.C.: Shortest connection networks and some generalizations, Bell 
+ * System Technical Journal, Vol. 36, 1957, 1389--1401.
+ *
+ * If the graph has more than one minimum spanning tree, the current 
+ * implementation returns always the same one.
+ *
+ * Directed graphs are considered as undirected for this computation.
+ *
+ * If the graph is not connected then its minimum spanning forest is returned.
+ * This is the set of the minimum spanning trees of each component. 
+ *
+ * The weights Array must contain the weights of the the edges. in the same 
+ * order as the simple edge iterator visits them. 
+ */
+VALUE cIGraph_minimum_spanning_tree_prim(VALUE self, VALUE weights){
+
+  igraph_t *graph;
+  igraph_t *n_graph = malloc(sizeof(igraph_t));
+  VALUE n_graph_obj;
+  igraph_vector_t weights_vec;
+  int i;
+
+  igraph_vector_init(&weights_vec,RARRAY(weights)->len);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  for(i=0;i<RARRAY(weights)->len;i++){
+    VECTOR(weights_vec)[i] = NUM2DBL(RARRAY(weights)->ptr[i]);
+  }
+
+  igraph_minimum_spanning_tree_prim(graph,n_graph,&weights_vec);
+
+  n_graph_obj = Data_Wrap_Struct(cIGraph, cIGraph_mark, cIGraph_free, n_graph);
+
+  igraph_vector_destroy(&weights_vec);
+
+  return n_graph_obj;
+
+}

data/ext/cIGraph_spectral.c

@@ -0,0 +1,57 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.laplacian(mode) -> Array
+ *
+ *  Returns the Laplacian matrix of a graph
+ *
+ * The graph Laplacian matrix is similar to an adjacency matrix but 
+ * contains -1's instead of 1's and the vertex degrees are included 
+ * in the diagonal. So the result for edge i--j is -1 if i!=j and is 
+ * equal to the degree of vertex i if i==j. igraph_laplacian will work 
+ * on a directed graph (although this does not seem to make much sense) 
+ * and ignores loops.
+ *
+ * Mode is a boolean specifying whether the normalized version should be used
+ * The normalised Laplacian matrix has 1 in the diagonal 
+ * and -1/sqrt(d[i]d[j]) if there is an edge from i to j.
+ *
+ * The first version of this function was written by Vincent Matossian. 
+ */
+VALUE cIGraph_laplacian(VALUE self, VALUE mode){
+
+  igraph_t *graph;
+  igraph_bool_t pmode = 0;
+  igraph_matrix_t res;
+  int i;
+  int j;
+  VALUE row;
+  VALUE val;
+  VALUE matrix = rb_ary_new();
+
+  if(mode = Qtrue)
+    pmode = 1;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //matrix to hold the results of the calculations
+  igraph_matrix_init(&res,igraph_vcount(graph),igraph_vcount(graph));
+
+  IGRAPH_CHECK(igraph_laplacian(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++){
+      val = rb_float_new(MATRIX(res,i,j));
+      rb_ary_push(row,val);
+    }
+  }
+
+  igraph_matrix_destroy(&res);
+
+  return matrix;
+
+}

data/ext/cIGraph_transitivity.c

@@ -0,0 +1,97 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.transitivity() -> Float
+ *
+ * Calculates the transitivity (clustering coefficient) of a graph.
+ *
+ * The transitivity measures the probability that two neighbors of a vertex 
+ * are connected. More precisely this is the ratio of the triangles and 
+ * connected triples in the graph, the result is a single real number or 
+ * NaN (0/0) if there are no connected triples in the graph. Directed graphs 
+ * are considered as undirected ones.
+ */
+VALUE cIGraph_transitivity(VALUE self){
+
+  igraph_t *graph;
+  igraph_real_t res;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_transitivity_undirected(graph,&res);
+
+  return rb_float_new(res);
+
+}
+
+/* call-seq:
+ *   graph.transitivity() -> Float
+ *
+ * Calculates the transitivity (clustering coefficient) of a graph.
+ *
+ * The transitivity measures the probability that two neighbors of a vertex 
+ * are connected. More precisely this is the ratio of the triangles and 
+ * connected triples in the graph, the result is a single real number or 
+ * NaN (0/0) if there are no connected triples in the graph. Directed graphs 
+ * are considered as undirected ones.
+ */
+VALUE cIGraph_transitivity_local(VALUE self, VALUE vs){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_vector_t res;
+  VALUE trans = rb_ary_new();
+  int i;
+
+  //vector to hold the results of the calculations
+  igraph_vector_init_int(&res,0);
+ 
+  //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);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_transitivity_local_undirected(graph,&res,vids);
+
+  for(i=0;i<igraph_vector_size(&res);i++){
+    rb_ary_push(trans,rb_float_new(VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return trans;
+
+}
+  
+/* call-seq:
+ *   graph.transitivity_avglocal() -> Float
+ *
+ * Calculates the transitivity (clustering coefficient) of a graph.
+ *
+ * The transitivity measures the probability that two neighbors of a vertex 
+ * are connected. More precisely this is the ratio of the triangles and 
+ * connected triples in the graph, the result is a single real number or 
+ * NaN (0/0) if there are no connected triples in the graph. Directed graphs 
+ * are considered as undirected ones.
+ */
+VALUE cIGraph_transitivity_avglocal(VALUE self){
+
+  igraph_t *graph;
+  igraph_real_t res;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_transitivity_avglocal_undirected(graph,&res);
+
+  return rb_float_new(res);
+
+}
+

data/ext/cIGraph_utility.c

@@ -49,7 +49,7 @@ int cIGraph_vertex_arr_to_id_vec(VALUE graph, VALUE va, igraph_vector_t *nv){
     rb_raise(cIGraphError, "Array expected\n");
     
   //Initialize edge vector
-  igraph_vector_init_int(nv,0);
+  //igraph_vector_init_int(nv,0);
   for (i=0; i<RARRAY(va)->len; i++) {
     vertex = RARRAY(va)->ptr[i];
     igraph_vector_push_back(nv,cIGraph_get_vertex_id(graph, vertex));

data/ext/cIGraph_vertex_neighbourhood.c

@@ -29,6 +29,7 @@ VALUE cIGraph_neighborhood_size(VALUE self, VALUE from, VALUE order, VALUE mode)
   igraph_vector_init(&res,0);
 
   //Convert an array of vertices to a vector of vertex ids
+  igraph_vector_init_int(&vidv,0);
   cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
   //create vertex selector from the vecotr of ids
   igraph_vs_vector(&vids,&vidv);
@@ -74,14 +75,18 @@ VALUE cIGraph_neighborhood(VALUE self, VALUE from, VALUE order, VALUE mode){
 
   Data_Get_Struct(self, igraph_t, graph);
 
-  igraph_vector_ptr_init(&res,0);
+  IGRAPH_FINALLY(igraph_vector_ptr_destroy,&res);
+  IGRAPH_CHECK(igraph_vector_ptr_init(&res,0));
 
   //Convert an array of vertices to a vector of vertex ids
+  IGRAPH_FINALLY(igraph_vector_destroy,&vidv);
+  igraph_vector_init_int(&vidv,0);
   cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
   //create vertex selector from the vecotr of ids
-  igraph_vs_vector(&vids,&vidv);
+  IGRAPH_FINALLY(igraph_vs_destroy,&vids);
+  IGRAPH_CHECK(igraph_vs_vector(&vids,&vidv));
 
-  igraph_neighborhood(graph,&res,vids,NUM2INT(order),pmode);
+  IGRAPH_CHECK(igraph_neighborhood(graph,&res,vids,NUM2INT(order),pmode));
 
   for(i=0; i<igraph_vector_ptr_size(&res); i++){
     neighbourhood = rb_ary_new();
@@ -94,12 +99,15 @@ VALUE cIGraph_neighborhood(VALUE self, VALUE from, VALUE order, VALUE mode){
 
   for(i=0;i<igraph_vector_ptr_size(&res);i++){
     igraph_vector_destroy(VECTOR(res)[i]);
+    free(VECTOR(res)[i]);
   }  
 
   igraph_vector_destroy(&vidv);
   igraph_vector_ptr_destroy(&res);
   igraph_vs_destroy(&vids);
 
+  IGRAPH_FINALLY_CLEAN(3);
+
   return matrix;
 
 }
@@ -133,6 +141,7 @@ VALUE cIGraph_neighborhood_graphs(VALUE self, VALUE from, VALUE order, VALUE mod
   igraph_vector_ptr_init(&res,0);
 
   //Convert an array of vertices to a vector of vertex ids
+  igraph_vector_init_int(&vidv,0);
   cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
   //create vertex selector from the vecotr of ids
   igraph_vs_vector(&vids,&vidv);

data/test/tc_cores.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_coreness
+    g = IGraph.new(['A','B','C','D'],true)
+    c = g.coreness(IGraph::ALL)
+    assert_equal c.length, g.vcount
+  end
+end

data/test/tc_directedness.rb

@@ -0,0 +1,31 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_directed_conv
+
+    g = IGraph.new(['A','B','B','C','C','D'],false)
+
+    g.to_directed(IGraph::ARBITRARY)
+    assert g.are_connected?('A','B') || g.are_connected?('B','A')
+    assert !(g.are_connected?('A','B') && g.are_connected?('B','A'))
+
+    g = IGraph.new(['A','B','B','C','C','D'],false)
+
+    g.to_directed(IGraph::MUTUAL)
+    assert g.are_connected?('A','B') && g.are_connected?('B','A')
+
+  end
+  def test_undirected
+    g = IGraph.new(['A','B','B','A','B','C','C','D'],true)
+    
+    g.to_undirected(IGraph::EACH)
+    assert_equal 4, g.ecount
+
+    g = IGraph.new(['A','B','B','A','B','C','C','D'],true)
+    
+    g.to_undirected(IGraph::COLLAPSE)
+    assert_equal 3, g.ecount
+
+  end  
+end

data/test/tc_shortest_paths.rb

@@ -34,9 +34,9 @@ class TestGraph < Test::Unit::TestCase
     graph = IGraph.new(['A','B','A','C','B','D'],true)    
     m = graph.diameter(true,true)
     assert_equal 3, m.length
-    assert_raises IGraphError do 
-      graph.girth
-    end
+    #assert_raises IGraphError do 
+    #  graph.girth
+    #end
     graph = IGraph.new(['A','B','A','C','B','D','C','D'],true)    
     assert_equal 4, graph.girth.length
   end

data/test/tc_spanning.rb

@@ -0,0 +1,24 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_minimum_span_tree
+    g = IGraph.new(['A','B','B','C','C','D','A','D'],true)
+    st = g.minimum_spanning_tree_unweighted()
+    assert_kind_of IGraph, st
+    assert_equal ['A','B','C','D'], st.to_a.sort
+  end
+  def test_minimum_span_tree_prim
+    g = IGraph.new(['A','B','B','C','C','D','A','D'],true)
+    st = g.minimum_spanning_tree_prim([1,1,5,1])
+    assert_kind_of IGraph, st
+    assert_equal ['A','B','C','D'], st.to_a.sort
+    assert  st.are_connected?('A','D')
+    assert !st.are_connected?('C','D')
+    st = g.minimum_spanning_tree_prim([1,1,1,5])
+    assert_kind_of IGraph, st
+    assert_equal ['A','B','C','D'], st.to_a.sort
+    assert !st.are_connected?('A','D')
+    assert  st.are_connected?('C','D')
+  end 
+end

data/test/tc_spectral.rb

@@ -0,0 +1,12 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_laplacian
+    g = IGraph.new(['A','B','C','D'],false)
+    m = g.laplacian(false)
+    assert_equal m.length, g.vcount
+    m = g.laplacian(true)
+    assert_equal m.length, g.vcount
+  end
+end

data/test/tc_thrash.rb

@@ -0,0 +1,41 @@
+require 'test/unit'
+require 'igraph'
+
+class Array
+  def mean
+    total = 0.0
+    self.each do |i|
+      total += i
+    end
+    total / self.length.to_f
+  end
+end
+
+class TestGraph < Test::Unit::TestCase
+  def test_thrash
+    g = IGraph.new([],true)
+    v = 100
+    v.times do |x|
+      g.add_vertex(x)
+    end
+    200.times do |x|
+      g.add_edge(rand(v/2),rand(v/2))
+    end
+    200.times do |x|
+      g.add_edge(rand(v/2)+v/2,rand(v/2)+v/2)
+    end    
+    assert_equal v, g.vcount
+    h,i = g.decompose(IGraph::WEAK,-1,2)
+
+    p h.vcount
+    p i.vcount
+
+    p h.degree(h.to_a[20..30],IGraph::ALL,false).mean
+    p h.degree(h.to_a[10..20],IGraph::ALL,false).mean
+
+    p h.betweenness(h.to_a[20..30],true).mean
+    p h.betweenness(h.to_a[10..20],true).mean
+
+  end
+end
+ 

data/test/tc_transitivity.rb

@@ -0,0 +1,17 @@
+require 'test/unit'
+require 'igraph'
+
+class TestGraph < Test::Unit::TestCase
+  def test_trans
+    g = IGraph.new(['A','B','A','C','A','D','B','C'],true)
+    assert_equal 0.6, g.transitivity
+  end
+  def test_trans_local
+    g = IGraph.new(['A','B','A','C','A','D','B','C'],true)
+    assert_in_delta 0.33, g.transitivity_local(['A'])[0], 0.01   
+  end
+  def test_trans_avr_local
+    g = IGraph.new(['A','B','A','C','A','D','B','C'],true)
+    assert_equal 0.6, g.transitivity
+  end
+end

data/test/test_all.rb

@@ -12,10 +12,15 @@ require 'tc_basic_properties'
 require 'tc_centrality'
 require 'tc_components'
 require 'tc_copy'
+require 'tc_cores'
+require 'tc_directedness'
 require 'tc_error_handling'
 require 'tc_file_read_write'
 require 'tc_layout'
 require 'tc_matrix'
 require 'tc_shortest_paths'
+require 'tc_spanning'
+require 'tc_spectral'
 require 'tc_topological_sort'
+require 'tc_transitivity'
 require 'tc_vertex_neighbourhood'

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: igraph
 version: !ruby/object:Gem::Version 
-  version: "0.3"
-date: 2007-08-16 00:00:00 +09:00
+  version: 0.3.1
+date: 2007-08-31 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
@@ -33,6 +33,7 @@ files:
 - License.txt
 - Manifest.txt
 - README.txt
+- Rakefile.rb
 - ext/cIGraph.c
 - ext/cIGraph.h
 - ext/cIGraph_add_delete.c
@@ -41,17 +42,23 @@ files:
 - ext/cIGraph_basic_query.c
 - ext/cIGraph_centrality.c
 - ext/cIGraph_components.c
+- ext/cIGraph_direction.c
 - ext/cIGraph_error_handlers.c
 - ext/cIGraph_file.c
 - ext/cIGraph_iterators.c
+- ext/cIGraph_kcores.c
 - ext/cIGraph_layout.c
 - ext/cIGraph_matrix.c
 - ext/cIGraph_operators.c
 - ext/cIGraph_selectors.c
 - ext/cIGraph_shortest_paths.c
+- ext/cIGraph_spanning.c
+- ext/cIGraph_spectral.c
 - ext/cIGraph_topological_sort.c
+- ext/cIGraph_transitivity.c
 - ext/cIGraph_utility.c
 - ext/cIGraph_vertex_neighbourhood.c
+- ext/extconf.rb
 - test/tc_add_delete.rb
 - test/tc_attributes.rb
 - test/tc_basic_properties.rb
@@ -59,7 +66,9 @@ files:
 - test/tc_centrality.rb
 - test/tc_components.rb
 - test/tc_copy.rb
+- test/tc_cores.rb
 - test/tc_create.rb
+- test/tc_directedness.rb
 - test/tc_error_handling.rb
 - test/tc_file_read_write.rb
 - test/tc_iterators.rb
@@ -67,7 +76,11 @@ files:
 - test/tc_matrix.rb
 - test/tc_selectors.rb
 - test/tc_shortest_paths.rb
+- test/tc_spanning.rb
+- test/tc_spectral.rb
+- test/tc_thrash.rb
 - test/tc_topological_sort.rb
+- test/tc_transitivity.rb
 - test/tc_vertex_neighbourhood.rb
 - test/test_all.rb
 test_files: