igraph 0.1.1 → 0.3

data/History.txt

@@ -1,3 +1,15 @@
-= 0.1 2007-06-29
+= 0.3 2007-08-16
 
-* First version
+* Over-hauled attribute code
+* Some file read/write support
+
+= 0.2 2007-07-31
+
+* First public (announced) release
+* Updated functions and documentation
+
+= 0.1 2007-07-16
+
+* First private release
+* Graph generation and manipulation functions implemented
+* Selection of basic querying functions implemented

data/Manifest.txt

@@ -5,20 +5,37 @@ README.txt
 ext/cIGraph.c
 ext/cIGraph.h
 ext/cIGraph_add_delete.c
+ext/cIGraph_attribute_handler.c
 ext/cIGraph_basic_properties.c
 ext/cIGraph_basic_query.c
+ext/cIGraph_centrality.c
+ext/cIGraph_components.c
 ext/cIGraph_error_handlers.c
+ext/cIGraph_file.c
 ext/cIGraph_iterators.c
+ext/cIGraph_layout.c
+ext/cIGraph_matrix.c
 ext/cIGraph_operators.c
 ext/cIGraph_selectors.c
 ext/cIGraph_shortest_paths.c
+ext/cIGraph_topological_sort.c
 ext/cIGraph_utility.c
+ext/cIGraph_vertex_neighbourhood.c
 test/tc_add_delete.rb
+test/tc_attributes.rb
 test/tc_basic_properties.rb
 test/tc_basic_query.rb
+test/tc_centrality.rb
+test/tc_components.rb
+test/tc_copy.rb
 test/tc_create.rb
 test/tc_error_handling.rb
+test/tc_file_read_write.rb
 test/tc_iterators.rb
+test/tc_layout.rb
+test/tc_matrix.rb
 test/tc_selectors.rb
 test/tc_shortest_paths.rb
+test/tc_topological_sort.rb
+test/tc_vertex_neighbourhood.rb
 test/test_all.rb

data/README.txt

@@ -1,33 +1,38 @@
 == Introduction
 
-IGraph
+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.
 
-IGraph
+IGraph is currently in alpha status and although the basic graph creation and manipulation functions are implemented the API should be considered subject to change. The main documentation can be found at http://igraph.rubyforge.org/igraph/.
 
-IGraph
+All bug reports, feature requests and patches are welcome. Please email alexg (at) kuicr.kyoto-u.ac.jp or use the rubyforge forums: http://rubyforge.org/forum/?group_id=3943
 
 == Installation
 
-A working igraph library installation is required.
+A working igraph library installation is required. Please see the igraph homepage (http://cneurocvs.rmki.kfki.hu/igraph/) for details on installing igraph.
 
-An IGraph gem is available as well as a package using setup.rb. In each case the installation requires the location of your igraph library to compile the extension. If you download the setup.rb package use these incantations:
+IGraph is only available as a gem. The installation requires the location of your igraph headers and library to compile the extension. For example, under Ubuntu linux the following command succesfully compiles and installs (you may need to be root):
 
-  ruby setup.rb config -- --with-igraph-dir=$R_HOME
-  ruby setup.rb setup
-  ruby setup.rb install
+  gem install igraph -- --with-igraph-include=/usr/local/include/igraph
 
-Using gems it is almost the same:
+== Documentation
 
-  gem install igraph -- --with-igraph-dir=$R_HOME
+Graph objects are represented in the IGraph class. See the IGraph class documentation for a list of available methods available to build and query graph objects. Any object can be used as a vertex and any edge can be annotated with any kind of object.
 
-== Documentation
+Note that many functions require 'mode' constants to tell igraph how you want certain calculations to be made. The constants are listed under the IGraph documentation and should also be made explicit in each methods documentation.
 
 Here is a very quick and simple example:
 
  require 'igraph'
 
+ #Create an empty directed graph
  graph = IGraph.new([],true)
 
+ #Add two edges (unannotated)
+ graph.add_edges([1,2,3,4])
+
+ #Count the number of vertices
+ graph.vcount # returns 4
+
 == License
 
 Copyright (C) 2006 Alex Gutteridge

data/ext/cIGraph.c

@@ -2,22 +2,58 @@
 #include "ruby.h"
 #include "cIGraph.h"
 
+//Classes
+VALUE cIGraph;
+VALUE cIGraphError;
+
 void cIGraph_free(void *p){
   igraph_destroy(p);
 }
 
+void cIGraph_mark(void *p){
+  rb_gc_mark(((VALUE*)((igraph_t*)p)->attr)[0]);
+  rb_gc_mark(((VALUE*)((igraph_t*)p)->attr)[1]);
+  rb_gc_mark(((VALUE*)((igraph_t*)p)->attr)[2]);
+}
+
 VALUE cIGraph_alloc(VALUE klass){
 
   igraph_t *graph = malloc(sizeof(igraph_t));
   VALUE obj;
 
   igraph_empty(graph, 0, 1);
-  obj = Data_Wrap_Struct(klass, 0, cIGraph_free, graph);
+
+  obj = Data_Wrap_Struct(klass, cIGraph_mark, cIGraph_free, graph);
 
   return obj;
   
 }
 
+/* Document-method: initialize_copy
+ *
+ * Internal method for copying IGraph objects.
+ */
+VALUE cIGraph_init_copy(VALUE copy, VALUE orig){
+
+  igraph_t *orig_graph;
+  igraph_t *copy_graph;
+
+  if (copy == orig)
+    return copy;
+
+  if(TYPE(orig) != T_DATA || RDATA(orig)->dfree != (RUBY_DATA_FUNC)cIGraph_free){
+    rb_raise(rb_eTypeError, "Wrong argument type.");
+  }
+  
+  Data_Get_Struct(copy, igraph_t, copy_graph); 
+  Data_Get_Struct(orig, igraph_t, orig_graph);
+
+  igraph_copy(copy_graph,orig_graph);
+
+  return copy;
+
+}
+
 /* call-seq:
  *   IGraph.new(edges,directed) -> IGraph
  *
@@ -38,53 +74,84 @@ VALUE cIGraph_alloc(VALUE klass){
  * Vertex 3 is connected to vertex 4.
  */
 
-VALUE cIGraph_initialize(VALUE self, VALUE edges, VALUE directed){
+VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){
 
   igraph_t *graph;
   igraph_vector_t edge_v;
   VALUE vertex;
-  VALUE object_h;
-  VALUE id_h;
+  VALUE directed;
+  VALUE edges;
+  VALUE attrs;
+  VALUE v_ary;
   int vertex_n = 0;
   int current_vertex_id;
+  int i;
 
-  igraph_set_error_handler(cIGraph_error_handler);
-  igraph_set_warning_handler(cIGraph_warning_handler);  
+  igraph_vector_ptr_t vertex_attr;
+  igraph_vector_ptr_t edge_attr;
+
+  igraph_i_attribute_record_t v_attr_rec;
+  v_attr_rec.name  = "__RUBY__";
+  v_attr_rec.type  = IGRAPH_ATTRIBUTE_PY_OBJECT;
+  v_attr_rec.value = (void*)rb_ary_new();
+
+  igraph_i_attribute_record_t e_attr_rec;
+  e_attr_rec.name  = "__RUBY__";
+  e_attr_rec.type  = IGRAPH_ATTRIBUTE_PY_OBJECT;
+  e_attr_rec.value = (void*)rb_ary_new();
 
-  //New hash for mapping vertex objects to floats used by iGraph
-  object_h = rb_iv_set(self,"@object_ids",rb_hash_new());
-  id_h     = rb_iv_set(self,"@id_objects",rb_hash_new());
+  rb_scan_args(argc,argv,"12", &edges, &directed, &attrs);
 
   //Initialize edge vector
   igraph_vector_init_int(&edge_v,0);
 
+  igraph_vector_ptr_init(&vertex_attr,0);
+  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);
 
   //Loop through objects in edge Array
-  vertex = rb_ary_shift(edges);
-  while(vertex != Qnil){
-    if(rb_funcall(object_h,rb_intern("has_key?"),1,vertex)){
+  for (i=0; i<RARRAY(edges)->len; i++) {
+    vertex = RARRAY(edges)->ptr[i];
+    if(rb_ary_includes(v_ary,vertex)){
       //If @vertices includes this vertex then look up the vertex number
-      current_vertex_id = NUM2INT(rb_hash_aref(object_h,vertex));
+      current_vertex_id = NUM2INT(rb_funcall(v_ary,rb_intern("index"),1,vertex));
     } else {
-      //otherwise add a new entry to Hash
-      rb_hash_aset(object_h,vertex,INT2NUM(vertex_n));
-      rb_hash_aset(id_h,    INT2NUM(vertex_n),vertex);
+      //Otherwise add to the list of vertices
+      rb_ary_push(v_ary,vertex);
       current_vertex_id = vertex_n;
       vertex_n++;
+      
+      //Add object to list of vertex attributes
+      rb_ary_push((VALUE)v_attr_rec.value,vertex);
+      
     }
     igraph_vector_push_back(&edge_v,current_vertex_id);
-    vertex = rb_ary_shift(edges);
+    if (i % 2){
+      if (attrs != Qnil){
+	rb_ary_push((VALUE)e_attr_rec.value,RARRAY(attrs)->ptr[i/2]);
+      } else {
+	rb_ary_push((VALUE)e_attr_rec.value,Qnil);
+      }
+    }
   }
 
+  igraph_vector_ptr_push_back(&vertex_attr, &v_attr_rec);
+  igraph_vector_ptr_push_back(&edge_attr,   &e_attr_rec);
+
   if(igraph_vector_size(&edge_v) > 0){
-    igraph_add_vertices(graph,vertex_n,0);
-    igraph_add_edges(graph,&edge_v,0);
+    igraph_add_vertices(graph,vertex_n,&vertex_attr);
+    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);
 
   return self;
 
@@ -96,65 +163,134 @@ VALUE cIGraph_initialize(VALUE self, VALUE edges, VALUE directed){
  */
 
 void Init_igraph(){
-  cIGraph = rb_define_class("IGraph", rb_cObject);
+
+  igraph_i_set_attribute_table(&cIGraph_attribute_table);
+  igraph_set_error_handler(cIGraph_error_handler);
+  igraph_set_warning_handler(cIGraph_warning_handler);  
+
+  cIGraph      = rb_define_class("IGraph",      rb_cObject);
   cIGraphError = rb_define_class("IGraphError", rb_eRuntimeError);
 
   rb_define_alloc_func(cIGraph, cIGraph_alloc);
-  rb_define_method(cIGraph, "initialize", cIGraph_initialize, 2);
+  rb_define_method(cIGraph, "initialize",      cIGraph_initialize, -1);
+  rb_define_method(cIGraph, "initialize_copy", cIGraph_init_copy,   1);
 
-  rb_define_method(cIGraph, "each_vertex",   cIGraph_each_vertex,  0); /* in cIGraph_iterators.c */
-  rb_define_method(cIGraph, "each_edge",     cIGraph_each_edge,    1); /* in cIGraph_iterators.c */
-  rb_define_method(cIGraph, "each_edge_eid", cIGraph_each_edge_eid,1); /* in cIGraph_iterators.c */ 
+  rb_include_module(cIGraph, rb_mEnumerable);
+
+  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.3"));
 
   rb_define_const(cIGraph, "EDGEORDER_ID",   INT2NUM(1));
   rb_define_const(cIGraph, "EDGEORDER_FROM", INT2NUM(2));
   rb_define_const(cIGraph, "EDGEORDER_TO",   INT2NUM(3));
 
-  rb_define_method(cIGraph, "each",        cIGraph_each_vertex, 0);
-  rb_include_module(cIGraph, rb_mEnumerable);
-
-  rb_define_method(cIGraph, "include?", cIGraph_include, 1);
-
-  rb_define_method(cIGraph, "all_vertices",         cIGraph_all_v,    0);
-  rb_define_method(cIGraph, "vertices",             cIGraph_all_v,    0); /* in cIGraph_selectors.c */
-  rb_define_method(cIGraph, "adjacent_vertices",    cIGraph_adj_v,    2); /* in cIGraph_selectors.c */
-  rb_define_method(cIGraph, "nonadjacent_vertices", cIGraph_nonadj_v, 2); /* in cIGraph_selectors.c */
-
-  rb_define_method(cIGraph, "all_edges",         cIGraph_all_e,    1);
-  rb_define_method(cIGraph, "edges",             cIGraph_all_e,    1);
-  rb_define_method(cIGraph, "adjacent_edges",    cIGraph_adj_e,    2);
-  rb_define_method(cIGraph, "nonadjacent_edges", cIGraph_nonadj_e, 2);  
-
-  rb_define_method(cIGraph, "vcount", cIGraph_vcount, 0); /* in cIGraph_basic_query.c */
-  rb_define_method(cIGraph, "ecount", cIGraph_ecount, 0); /* in cIGraph_basic_query.c */
-
-  rb_define_method(cIGraph, "edge",    cIGraph_edge, 1); /* in cIGraph_basic_query.c */
-  rb_define_method(cIGraph, "get_eid", cIGraph_get_eid, 2); /* in cIGraph_basic_query.c */
-
-  rb_define_method(cIGraph, "neighbors",  cIGraph_neighbors,2);
-  rb_define_method(cIGraph, "neighbours", cIGraph_neighbors,2); /* in cIGraph_basic_query.c */
-  rb_define_method(cIGraph, "adjacent",   cIGraph_adjacent,2); /* in cIGraph_basic_query.c */
-
   rb_define_const(cIGraph, "OUT",   INT2NUM(1));
   rb_define_const(cIGraph, "IN",    INT2NUM(2));
   rb_define_const(cIGraph, "ALL",   INT2NUM(3));
   rb_define_const(cIGraph, "TOTAL", INT2NUM(4));
-  
-  rb_define_method(cIGraph, "is_directed",  cIGraph_is_directed,0);
-  rb_define_method(cIGraph, "is_directed?", cIGraph_is_directed,0); /* in cIGraph_basic_query.c */ 
 
-  rb_define_method(cIGraph, "degree", cIGraph_degree,3); /* in cIGraph_basic_query.c */
+  rb_define_const(cIGraph, "WEAK",   INT2NUM(1));
+  rb_define_const(cIGraph, "STRONG", INT2NUM(2));  
 
-  rb_define_method(cIGraph, "add_edges",    cIGraph_add_edges,    1); /* in cIGraph_add_delete.c */
-  rb_define_method(cIGraph, "add_vertices", cIGraph_add_vertices, 1); /* in cIGraph_add_delete.c */
+  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", "[]");
+  rb_define_alias (cIGraph, "set_edge_attr", "[]=");
 
-  rb_define_method(cIGraph, "add_edge",   cIGraph_add_edge,   2); /* in cIGraph_add_delete.c */
-  rb_define_method(cIGraph, "add_vertex", cIGraph_add_vertex, 1); /* in cIGraph_add_delete.c */
+  rb_define_method(cIGraph, "attributes", cIGraph_graph_attributes, 0); /* in cIGraph_attribute_handler.c */
 
-  rb_define_method(cIGraph, "are_connected",  cIGraph_are_connected,2);
-  rb_define_method(cIGraph, "are_connected?", cIGraph_are_connected,2); /* in cIGraph_basic_properties.c */  
+  rb_define_method(cIGraph, "each_vertex",   cIGraph_each_vertex,  0); /* in cIGraph_iterators.c */
+  rb_define_method(cIGraph, "each_edge",     cIGraph_each_edge,    1); /* in cIGraph_iterators.c */
+  rb_define_method(cIGraph, "each_edge_eid", cIGraph_each_edge_eid,1); /* in cIGraph_iterators.c */ 
+  rb_define_alias (cIGraph, "each", "each_vertex");
 
-  rb_define_method(cIGraph, "shortest_paths",     cIGraph_shortest_paths,2);
-  rb_define_method(cIGraph, "get_shortest_paths", cIGraph_get_shortest_paths,3);
+  rb_define_method(cIGraph, "vertices",             cIGraph_all_v,    0); /* in cIGraph_selectors.c */
+  rb_define_method(cIGraph, "adjacent_vertices",    cIGraph_adj_v,    2); /* in cIGraph_selectors.c */
+  rb_define_method(cIGraph, "nonadjacent_vertices", cIGraph_nonadj_v, 2); /* in cIGraph_selectors.c */
+  rb_define_alias (cIGraph, "all_vertices", "vertices");
+
+  rb_define_method(cIGraph, "edges",                cIGraph_all_e,    1); /* in cIGraph_selectors.c */
+  rb_define_method(cIGraph, "adjacent_edges",       cIGraph_adj_e,    2); /* in cIGraph_selectors.c */
+  rb_define_alias (cIGraph, "all_edges", "edges");
+
+  rb_define_method(cIGraph, "vcount",       cIGraph_vcount,      0); /* in cIGraph_basic_query.c */
+  rb_define_method(cIGraph, "ecount",       cIGraph_ecount,      0); /* in cIGraph_basic_query.c */
+  rb_define_method(cIGraph, "edge",         cIGraph_edge,        1); /* in cIGraph_basic_query.c */
+  rb_define_method(cIGraph, "get_eid",      cIGraph_get_eid,     2); /* in cIGraph_basic_query.c */
+  rb_define_method(cIGraph, "neighbours",   cIGraph_neighbors,   2); /* in cIGraph_basic_query.c */
+  rb_define_method(cIGraph, "adjacent",     cIGraph_adjacent,    2); /* in cIGraph_basic_query.c */
+  rb_define_method(cIGraph, "degree",       cIGraph_degree,      3); /* in cIGraph_basic_query.c */
+  rb_define_method(cIGraph, "is_directed?", cIGraph_is_directed, 0); /* in cIGraph_basic_query.c */ 
+  rb_define_alias (cIGraph, "is_directed",  "is_directed?");
+  rb_define_alias (cIGraph, "neighbors",    "neighbours");
+
+  rb_define_method(cIGraph, "add_edges",     cIGraph_add_edges,    -1); /* in cIGraph_add_delete.c */
+  rb_define_method(cIGraph, "add_vertices",  cIGraph_add_vertices,  1); /* in cIGraph_add_delete.c */
+  rb_define_method(cIGraph, "add_edge",      cIGraph_add_edge,     -1); /* in cIGraph_add_delete.c */
+  rb_define_method(cIGraph, "add_vertex",    cIGraph_add_vertex,    1); /* in cIGraph_add_delete.c */
+  rb_define_method(cIGraph, "delete_edge",   cIGraph_delete_edge,   2); /* in cIGraph_add_delete.c */
+  rb_define_method(cIGraph, "delete_vertex", cIGraph_delete_vertex, 1); /* in cIGraph_add_delete.c */
+
+  rb_define_method(cIGraph, "are_connected",  cIGraph_are_connected,2); /* in cIGraph_basic_properties.c */  
+  rb_define_alias (cIGraph, "are_connected?", "are_connected");
+
+  rb_define_method(cIGraph, "shortest_paths",         cIGraph_shortest_paths,         2); /* in cIGraph_shortest_paths.c */
+  rb_define_method(cIGraph, "get_shortest_paths",     cIGraph_get_shortest_paths,     3); /* in cIGraph_shortest_paths.c */
+  rb_define_method(cIGraph, "get_all_shortest_paths", cIGraph_get_all_shortest_paths, 3); /* in cIGraph_shortest_paths.c */  
+  rb_define_method(cIGraph, "average_path_length",    cIGraph_average_path_length,    2); /* in cIGraph_shortest_paths.c */  
+  rb_define_method(cIGraph, "diameter",               cIGraph_diameter,               2); /* in cIGraph_shortest_paths.c */
+  rb_define_method(cIGraph, "girth",                  cIGraph_girth,                  0); /* in cIGraph_shortest_paths.c */
+
+  rb_define_method(cIGraph, "neighbourhood_size",   cIGraph_neighborhood_size,   3); /* in cIGraph_vertex_neighbourhood.c */
+  rb_define_method(cIGraph, "neighbourhood",        cIGraph_neighborhood,        3); /* in cIGraph_vertex_neighbourhood.c */
+  rb_define_method(cIGraph, "neighbourhood_graphs", cIGraph_neighborhood_graphs, 3); /* in cIGraph_vertex_neighbourhood.c */
+  rb_define_alias (cIGraph, "neighborhood_size", "neighbourhood_size");
+  rb_define_alias (cIGraph, "neighborhood", "neighbourhood");
+  rb_define_alias (cIGraph, "neighborhood_graphs", "neighbourhood_graphs");
+
+  rb_define_method(cIGraph, "subcomponent", cIGraph_subcomponent, 2); /* in cIGraph_components.c */
+  rb_define_method(cIGraph, "subgraph",     cIGraph_subgraph,     1); /* in cIGraph_components.c */
+  rb_define_method(cIGraph, "clusters",     cIGraph_clusters,     1); /* in cIGraph_components.c */
+  rb_define_method(cIGraph, "decompose",    cIGraph_decompose,   -1); /* in cIGraph_components.c */
+
+  rb_define_method(cIGraph, "closeness",        cIGraph_closeness,        2); /* in cIGraph_centrality.c */
+  rb_define_method(cIGraph, "betweenness",      cIGraph_betweenness,      2); /* in cIGraph_centrality.c */
+  rb_define_method(cIGraph, "edge_betweenness", cIGraph_edge_betweenness, 1); /* in cIGraph_centrality.c */
+  rb_define_method(cIGraph, "pagerank",         cIGraph_pagerank,         5); /* in cIGraph_centrality.c */  
+  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, "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 */
+  rb_define_singleton_method(cIGraph, "read_graph_graphml", cIGraph_read_graph_graphml, 2);   /* in cIGraph_file.c */  
+  rb_define_singleton_method(cIGraph, "read_graph_pajek", cIGraph_read_graph_pajek, 2);       /* in cIGraph_file.c */  
+  rb_define_method(cIGraph, "write_graph_edgelist", cIGraph_write_graph_edgelist, 1);         /* in cIGraph_file.c */
+  rb_define_method(cIGraph, "write_graph_graphml", cIGraph_write_graph_graphml,   1);         /* in cIGraph_file.c */  
+  rb_define_method(cIGraph, "write_graph_pajek", cIGraph_write_graph_pajek, 1);               /* in cIGraph_file.c */
+
+  rb_define_method(cIGraph, "layout_random",               cIGraph_layout_random,               0); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_circle",               cIGraph_layout_circle,               0); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_fruchterman_reingold", cIGraph_layout_fruchterman_reingold, 6); /* in cIGraph_layout.c */
+
+  //Matrix class
+  cIGraphMatrix = rb_define_class("IGraphMatrix", rb_cObject);
+
+  rb_define_alloc_func(cIGraphMatrix, cIGraph_matrix_alloc);
+  rb_define_method(cIGraphMatrix, "initialize",      cIGraph_matrix_initialize, -1); /* in cIGraph_matrix.c */
+  rb_define_method(cIGraphMatrix, "initialize_copy", cIGraph_matrix_init_copy,   1); /* in cIGraph_matrix.c */
+  //rb_define_singleton_method(cIGraphMatrix, "[]",    cIGraph_matrix_initialize, -1);
+  rb_include_module(cIGraphMatrix, rb_mEnumerable);
+  rb_define_method (cIGraphMatrix, "each", cIGraph_matrix_each,0); /* in cIGraph_matrix.c */
+ 
+  rb_define_method(cIGraphMatrix, "[]",   cIGraph_matrix_get,  2); /* in cIGraph_matrix.c */
+  rb_define_method(cIGraphMatrix, "[]=",  cIGraph_matrix_set,  3); /* in cIGraph_matrix.c */
+  rb_define_method(cIGraphMatrix, "size", cIGraph_matrix_size, 0); /* in cIGraph_matrix.c */
+  rb_define_method(cIGraphMatrix, "nrow", cIGraph_matrix_nrow, 0); /* in cIGraph_matrix.c */
+  rb_define_method(cIGraphMatrix, "ncol", cIGraph_matrix_ncol, 0); /* in cIGraph_matrix.c */
+  rb_define_method(cIGraphMatrix, "max",  cIGraph_matrix_max,  0); /* in cIGraph_matrix.c */
+
+  rb_define_method(cIGraphMatrix, "*", cIGraph_matrix_multiply, 1); /* in cIGraph_matrix.c */
+
+  rb_define_method(cIGraphMatrix, "to_a", cIGraph_matrix_toa, 0); /* in cIGraph_matrix.c */
 
 }

data/ext/cIGraph.h

@@ -1,6 +1,14 @@
+#include "math.h"
+#include "ruby.h"
+#include "igraph.h"
+
+//#define DEBUG
+
 //Classes
-VALUE cIGraph;
-VALUE cIGraphError;
+extern VALUE cIGraph;
+extern VALUE cIGraphError;
+extern VALUE cIGraphMatrix;
+extern igraph_attribute_table_t cIGraph_attribute_table;
 
 //Error and warning handling functions
 void cIGraph_error_handler(const char *reason, const char *file,
@@ -17,8 +25,17 @@ VALUE cIGraph_include(VALUE self, VALUE v);
 //IGraph allocation, destruction and intialization
 void Init_igraph(void);
 void cIGraph_free(void *p);
+void cIGraph_mark(void *p);
 VALUE cIGraph_alloc(VALUE klass);
-VALUE cIGraph_initialize(VALUE self, VALUE edges, VALUE directed);
+VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self);
+VALUE cIGraph_init_copy(VALUE copy, VALUE orig);
+
+//Attribute accessors
+int replace_i(VALUE key, VALUE val, VALUE hash);
+VALUE cIGraph_get_edge_attr(VALUE self, VALUE from, VALUE to);
+VALUE cIGraph_set_edge_attr(VALUE self, VALUE from, VALUE to, VALUE attr);
+VALUE cIGraph_graph_attributes(VALUE self);
+igraph_i_attribute_record_t cIGraph_create_record(VALUE v);
 
 //Iterators
 VALUE cIGraph_each_vertex  (VALUE self);
@@ -32,7 +49,6 @@ VALUE cIGraph_nonadj_v(VALUE self, VALUE v, VALUE mode);
 
 VALUE cIGraph_all_e   (VALUE self,          VALUE mode);
 VALUE cIGraph_adj_e   (VALUE self, VALUE v, VALUE mode);
-VALUE cIGraph_nonadj_e(VALUE self, VALUE v, VALUE mode);
 
 //Basic query operations
 VALUE cIGraph_vcount     (VALUE self);
@@ -45,16 +61,147 @@ VALUE cIGraph_is_directed(VALUE self);
 VALUE cIGraph_degree     (VALUE self, VALUE v, VALUE mode, VALUE loops);
 
 //Adding and eleting vertices and edges
-VALUE cIGraph_add_edges      (VALUE self, VALUE edges);
+VALUE cIGraph_add_edges      (int argc, VALUE *argv, VALUE self);
+VALUE cIGraph_add_edge       (int argc, VALUE *argv, VALUE self);
 VALUE cIGraph_add_vertices   (VALUE self, VALUE vs);
+VALUE cIGraph_delete_edge    (VALUE self, VALUE from, VALUE to);
 VALUE cIGraph_delete_edges   (VALUE self, VALUE edges);
 VALUE cIGraph_delete_vertices(VALUE self, VALUE vs);
-VALUE cIGraph_add_edge       (VALUE self, VALUE from, VALUE to);
+VALUE cIGraph_delete_vertex  (VALUE self, VALUE v);
 VALUE cIGraph_add_vertex     (VALUE self, VALUE v);
 
 //Basic properties
 VALUE cIGraph_are_connected(VALUE self, VALUE from, VALUE to);
 
 //Shortest Path Related Functions
-VALUE cIGraph_shortest_paths    (VALUE self, VALUE from, VALUE mode);
-VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode);
+VALUE cIGraph_shortest_paths        (VALUE self, VALUE from, VALUE mode);
+VALUE cIGraph_get_shortest_paths    (VALUE self, VALUE from, VALUE to, VALUE mode);
+VALUE cIGraph_get_all_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode); 
+VALUE cIGraph_average_path_length   (VALUE self, VALUE directed, VALUE unconn);
+VALUE cIGraph_diameter              (VALUE self, VALUE directed, VALUE unconn);
+VALUE cIGraph_girth                 (VALUE self);
+
+//Vertex neighbourhood functions
+VALUE cIGraph_neighborhood_size  (VALUE self, VALUE from, VALUE order, VALUE mode);
+VALUE cIGraph_neighborhood       (VALUE self, VALUE from, VALUE order, VALUE mode);
+VALUE cIGraph_neighborhood_graphs(VALUE self, VALUE from, VALUE order, VALUE mode);
+
+//Component functions
+VALUE cIGraph_subcomponent(VALUE self, VALUE v, VALUE mode);
+VALUE cIGraph_subgraph    (VALUE self, VALUE vs);
+VALUE cIGraph_clusters    (VALUE self, VALUE mode);
+VALUE cIGraph_decompose   (int argc, VALUE *argv, VALUE self);
+
+//Centrality measures
+VALUE cIGraph_closeness       (VALUE self, VALUE vs, VALUE mode);
+VALUE cIGraph_betweenness     (VALUE self, VALUE vs, VALUE directed);
+VALUE cIGraph_edge_betweenness(VALUE self, VALUE directed);
+VALUE cIGraph_pagerank        (VALUE self, VALUE vs, VALUE directed, VALUE niter, VALUE eps, VALUE damping);
+VALUE cIGraph_constraint      (int argc, VALUE *argv, VALUE self);
+VALUE cIGraph_maxdegree       (VALUE self, VALUE vs, VALUE mode, VALUE loops);
+
+//Topological sorting
+VALUE cIGraph_topological_sorting(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);
+VALUE cIGraph_read_graph_graphml  (VALUE self, VALUE file, VALUE index);
+VALUE cIGraph_write_graph_graphml (VALUE self, VALUE file);
+VALUE cIGraph_read_graph_pajek    (VALUE self, VALUE file);
+VALUE cIGraph_write_graph_pajek   (VALUE self, VALUE file);
+
+//Layouts
+VALUE cIGraph_layout_random(VALUE self);
+VALUE cIGraph_layout_circle(VALUE self);
+VALUE cIGraph_layout_fruchterman_reingold(VALUE self,
+					  VALUE niter,
+					  VALUE maxdelta,
+					  VALUE area,
+					  VALUE coolexp,
+					  VALUE repulserad,
+					  VALUE use_seed);
+
+//Attributes
+int cIGraph_attribute_init(igraph_t *graph, 
+			   igraph_vector_ptr_t *attr);
+void cIGraph_attribute_destroy(igraph_t *graph);
+int cIGraph_attribute_copy(igraph_t *to, 
+			   const igraph_t *from);
+int cIGraph_attribute_add_vertices(igraph_t *graph, 
+				   long int nv, 
+				   igraph_vector_ptr_t *attr);
+void cIGraph_attribute_delete_edges(igraph_t *graph, 
+				    const igraph_vector_t *idx);
+void cIGraph_attribute_delete_vertices(igraph_t *graph,
+				       const igraph_vector_t *eidx,
+				       const igraph_vector_t *vidx);
+int cIGraph_attribute_add_edges(igraph_t *graph, 
+				const igraph_vector_t *edges, 
+				igraph_vector_ptr_t *attr);
+void cIGraph_attribute_delete_edges(igraph_t *graph, 
+				    const igraph_vector_t *idx);
+int cIGraph_attribute_permute_edges(igraph_t *graph,
+				    const igraph_vector_t *idx);
+int cIGraph_attribute_get_info(const igraph_t *graph,
+			       igraph_strvector_t *gnames,
+			       igraph_vector_t *gtypes,
+			       igraph_strvector_t *vnames,
+			       igraph_vector_t *vtypes,
+			       igraph_strvector_t *enames,
+			       igraph_vector_t *etypes);
+igraph_bool_t cIGraph_attribute_has_attr(const igraph_t *graph,
+					 igraph_attribute_elemtype_t type,
+					 const char* name);
+int cIGraph_attribute_get_type(const igraph_t *graph,
+			       igraph_attribute_type_t *type,
+			       igraph_attribute_elemtype_t elemtype,
+			       const char *name);
+int cIGraph_get_numeric_graph_attr(const igraph_t *graph,
+				   const char *name, 
+				   igraph_vector_t *value);
+int cIGraph_get_string_graph_attr(const igraph_t *graph,
+				  const char *name, 
+				  igraph_strvector_t *value);
+int cIGraph_get_numeric_vertex_attr(const igraph_t *graph,
+				    const char *name,
+				    igraph_vs_t vs,
+				    igraph_vector_t *value);
+int cIGraph_get_string_vertex_attr(const igraph_t *graph,
+				   const char *name,
+				   igraph_vs_t vs,
+				   igraph_strvector_t *value);
+int cIGraph_get_numeric_edge_attr(const igraph_t *graph,
+				  const char *name,
+				  igraph_es_t es,
+				  igraph_vector_t *value);
+int cIGraph_get_string_edge_attr(const igraph_t *graph,
+				 const char *name,
+				 igraph_es_t es,
+				 igraph_strvector_t *value);
+
+
+//Matrix functions
+void cIGraph_matrix_free(void *p);
+VALUE cIGraph_matrix_alloc(VALUE klass);
+VALUE cIGraph_matrix_init_copy(VALUE copy, VALUE orig);
+VALUE cIGraph_matrix_initialize(int argc, VALUE *argv, VALUE self);
+void Init_igraphmatrix();
+
+VALUE cIGraph_matrix_each(VALUE self);
+
+VALUE cIGraph_matrix_get (VALUE self, VALUE i, VALUE j);
+VALUE cIGraph_matrix_set (VALUE self, VALUE i, VALUE j, VALUE x);
+VALUE cIGraph_matrix_size(VALUE self);
+VALUE cIGraph_matrix_nrow(VALUE self);
+VALUE cIGraph_matrix_ncol(VALUE self);
+VALUE cIGraph_matrix_max (VALUE self);
+
+VALUE cIGraph_matrix_multiply(VALUE self, VALUE x);
+
+VALUE cIGraph_matrix_toa(VALUE self);
+
+//Not implemented yet
+//VALUE cIGraph_add_rows(VALUE self, VALUE n);
+//VALUE cIGraph_add_cols(VALUE self, VALUE n);
+//VALUE cIGraph_matrix_resize(VALUE self, VALUE nrow, VALUE ncol);