igraph 0.1.1

data/Manifest.txt

@@ -0,0 +1,24 @@
+History.txt
+License.txt
+Manifest.txt
+README.txt
+ext/cIGraph.c
+ext/cIGraph.h
+ext/cIGraph_add_delete.c
+ext/cIGraph_basic_properties.c
+ext/cIGraph_basic_query.c
+ext/cIGraph_error_handlers.c
+ext/cIGraph_iterators.c
+ext/cIGraph_operators.c
+ext/cIGraph_selectors.c
+ext/cIGraph_shortest_paths.c
+ext/cIGraph_utility.c
+test/tc_add_delete.rb
+test/tc_basic_properties.rb
+test/tc_basic_query.rb
+test/tc_create.rb
+test/tc_error_handling.rb
+test/tc_iterators.rb
+test/tc_selectors.rb
+test/tc_shortest_paths.rb
+test/test_all.rb

data/README.txt

@@ -0,0 +1,47 @@
+== Introduction
+
+IGraph
+
+IGraph
+
+IGraph
+
+== Installation
+
+A working igraph library installation is required.
+
+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:
+
+  ruby setup.rb config -- --with-igraph-dir=$R_HOME
+  ruby setup.rb setup
+  ruby setup.rb install
+
+Using gems it is almost the same:
+
+  gem install igraph -- --with-igraph-dir=$R_HOME
+
+== Documentation
+
+Here is a very quick and simple example:
+
+ require 'igraph'
+
+ graph = IGraph.new([],true)
+
+== License
+
+Copyright (C) 2006 Alex Gutteridge
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU Lesser General Public
+License as published by the Free Software Foundation; either
+version 2.1 of the License, or (at your option) any later version.
+
+This library is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+Lesser General Public License for more details.
+
+You should have received a copy of the GNU Lesser General Public
+License along with this library; if not, write to the Free Software
+Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

data/ext/cIGraph.c

@@ -0,0 +1,160 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+void cIGraph_free(void *p){
+  igraph_destroy(p);
+}
+
+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);
+
+  return obj;
+  
+}
+
+/* call-seq:
+ *   IGraph.new(edges,directed) -> IGraph
+ *
+ * Creates a new IGraph graph with the edges specified in the edges Array.
+ * The first two elements define the first edge (the order is from,to for 
+ * directed graphs). The next two define the second edge and so on. The 
+ * Array should contain an even number of elements. Graph elements can be
+ * any ruby object.
+ *
+ * The boolean value directed specifies whether a directed or undirected
+ * graph is created.
+ *
+ * Example:
+ *
+ *   IGraph.new([1,2,3,4],true)
+ *
+ * Creates a graph with four vertices. Vertex 1 is connected to vertex 2.
+ * Vertex 3 is connected to vertex 4.
+ */
+
+VALUE cIGraph_initialize(VALUE self, VALUE edges, VALUE directed){
+
+  igraph_t *graph;
+  igraph_vector_t edge_v;
+  VALUE vertex;
+  VALUE object_h;
+  VALUE id_h;
+  int vertex_n = 0;
+  int current_vertex_id;
+
+  igraph_set_error_handler(cIGraph_error_handler);
+  igraph_set_warning_handler(cIGraph_warning_handler);  
+
+  //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());
+
+  //Initialize edge vector
+  igraph_vector_init_int(&edge_v,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+  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)){
+      //If @vertices includes this vertex then look up the vertex number
+      current_vertex_id = NUM2INT(rb_hash_aref(object_h,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);
+      current_vertex_id = vertex_n;
+      vertex_n++;
+    }
+    igraph_vector_push_back(&edge_v,current_vertex_id);
+    vertex = rb_ary_shift(edges);
+  }
+
+  if(igraph_vector_size(&edge_v) > 0){
+    igraph_add_vertices(graph,vertex_n,0);
+    igraph_add_edges(graph,&edge_v,0);
+  }
+
+  igraph_vector_destroy(&edge_v);
+
+  return self;
+
+}
+
+/* Interface to the iGraph[http://cneurocvs.rmki.kfki.hu/igraph/] library
+ * for graph and network computation. See IGraph#new for how to create a
+ * graph and get started.
+ */
+
+void Init_igraph(){
+  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, "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_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_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,   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, "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, "shortest_paths",     cIGraph_shortest_paths,2);
+  rb_define_method(cIGraph, "get_shortest_paths", cIGraph_get_shortest_paths,3);
+
+}

data/ext/cIGraph.h

@@ -0,0 +1,60 @@
+//Classes
+VALUE cIGraph;
+VALUE cIGraphError;
+
+//Error and warning handling functions
+void cIGraph_error_handler(const char *reason, const char *file,
+			   int line, int igraph_errno);
+void cIGraph_warning_handler(const char *reason, const char *file,
+                             int line, int igraph_errno);
+
+//IGraph specific utility functions
+igraph_integer_t cIGraph_get_vertex_id(VALUE graph, VALUE v);
+VALUE cIGraph_get_vertex_object(VALUE graph, igraph_integer_t n);
+int cIGraph_vertex_arr_to_id_vec(VALUE graph, VALUE va, igraph_vector_t *nv);
+VALUE cIGraph_include(VALUE self, VALUE v);
+
+//IGraph allocation, destruction and intialization
+void Init_igraph(void);
+void cIGraph_free(void *p);
+VALUE cIGraph_alloc(VALUE klass);
+VALUE cIGraph_initialize(VALUE self, VALUE edges, VALUE directed);
+
+//Iterators
+VALUE cIGraph_each_vertex  (VALUE self);
+VALUE cIGraph_each_edge    (VALUE self, VALUE order);
+VALUE cIGraph_each_edge_eid(VALUE self, VALUE order);
+
+//Selectors
+VALUE cIGraph_all_v   (VALUE self);
+VALUE cIGraph_adj_v   (VALUE self, VALUE v, VALUE mode);
+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);
+VALUE cIGraph_ecount     (VALUE self);
+VALUE cIGraph_edge       (VALUE self, VALUE eid);
+VALUE cIGraph_get_eid    (VALUE self, VALUE from, VALUE to, VALUE directed);
+VALUE cIGraph_neighbors  (VALUE self, VALUE v, VALUE mode);
+VALUE cIGraph_adjacent   (VALUE self, VALUE v, VALUE mode);
+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_vertices   (VALUE self, VALUE vs);
+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_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);

data/ext/cIGraph_add_delete.c

@@ -0,0 +1,219 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.add_edges(edges) -> Fixnum
+ *
+ * Adds the edges in the edges Array to the graph. Edges are specified as an
+ * Array in the same way as with IGraph#new.
+ *
+ * Returns 0 on success.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.add_edges([1,4,2,3])
+ *
+ * Adds an extra directed edge to this trivial graph. Note that vertices
+ * must have already been added to the graph before they can be used in
+ * an edge (throws a IGraphError otherwise).
+ */
+VALUE cIGraph_add_edges(VALUE self, VALUE edges){
+
+  igraph_t *graph;
+  igraph_vector_t edge_v;
+  VALUE vertex;
+  VALUE object_h;
+  int vid;
+  int code = 0;
+
+  //Initialize edge vector
+  igraph_vector_init_int(&edge_v,0);
+  object_h = rb_iv_get(self,"@object_ids");
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //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)){
+      //If @vertices includes this vertex then look up the vertex number
+      vid = NUM2INT(rb_hash_aref(object_h,vertex));
+    } else {
+      rb_raise(cIGraphError, "Unknown vertex in edge array. Use add_vertices first");
+    }
+    igraph_vector_push_back(&edge_v,vid);
+    vertex = rb_ary_shift(edges);
+  }
+
+  if(igraph_vector_size(&edge_v) > 0){
+    code = igraph_add_edges(graph,&edge_v,0);
+  }
+
+  igraph_vector_destroy(&edge_v);
+
+  return INT2NUM(code);
+
+}
+
+/* call-seq:
+ *   graph.add_vertices(vs) -> Fixnum
+ *
+ * Adds the vertices in the vs Array to the graph.
+ *
+ * Returns 0 on success.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.add_vertices([5,6,7,8])
+ *
+ * Adds 4 extra vertices to this graph. IGraph will silently ignore attempts
+ * to add a vertex twice to the same graph.
+ */
+VALUE cIGraph_add_vertices(VALUE self, VALUE vs){
+
+  igraph_t *graph;
+  VALUE vertex;
+  VALUE object_h;
+  VALUE id_h;
+  int vertex_n;
+  int code = 0;
+  int length;
+
+  object_h = rb_iv_get(self,"@object_ids");
+  id_h     = rb_iv_get(self,"@id_objects");
+  length   = NUM2INT(rb_funcall(vs,      rb_intern("length"),0));
+  vertex_n = NUM2INT(rb_funcall(object_h,rb_intern("length"),0));
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Loop through objects in vertex array
+  vertex = rb_ary_shift(vs);
+  while(vertex != Qnil){
+    if(rb_funcall(object_h,rb_intern("has_key?"),1,vertex)){
+      //If @vertices includes this vertex then raise an error
+      //Silently ignore
+      //rb_raise(cIGraphError, "Vertex already added to graph");
+      length--;
+    } 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);
+      vertex_n++;
+    }
+    vertex = rb_ary_shift(vs);
+  }
+  code = igraph_add_vertices(graph,length,0);
+
+  return INT2NUM(code);
+
+}
+
+/* call-seq:
+ *   graph.add_edge(from,to) -> Fixnum
+ *
+ * Adds an edge between the two vertices given. This is just a convinience
+ * method, it is possible to use IGraph#add_edges to add a single edge as well
+ *
+ * Returns 0 on success.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.add_edge(1,4)
+ *
+ * Note that vertices must have already been added to the graph before 
+ * they can be used in an edge (throws a IGraphError otherwise).
+ */
+VALUE cIGraph_add_edge(VALUE self, VALUE from, VALUE to){
+
+  igraph_t *graph;
+  igraph_vector_t edge_v;
+  VALUE object_h;
+  int vid;
+  int code = 0;
+
+  //Initialize edge vector
+  igraph_vector_init_int(&edge_v,0);
+  object_h = rb_iv_get(self,"@object_ids");
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  if(rb_funcall(object_h,rb_intern("has_key?"),1,from)){
+    //If @vertices includes this vertex then look up the vertex number
+    vid = NUM2INT(rb_hash_aref(object_h,from));
+  } else {
+    rb_raise(cIGraphError, "Unknown vertex in edge array. Use add_vertices first");
+  }
+  igraph_vector_push_back(&edge_v,vid);
+
+  if(rb_funcall(object_h,rb_intern("has_key?"),1,to)){
+    //If @vertices includes this vertex then look up the vertex number
+    vid = NUM2INT(rb_hash_aref(object_h,to));
+  } else {
+    rb_raise(cIGraphError, "Unknown vertex in edge array. Use add_vertices first");
+  }
+  igraph_vector_push_back(&edge_v,vid);
+
+  code = igraph_add_edges(graph,&edge_v,0);
+
+  igraph_vector_destroy(&edge_v);
+
+  return INT2NUM(code);
+
+}
+
+/* call-seq:
+ *   graph.add_vertex(v) -> Fixnum
+ *
+ * Adds the vertex to the graph. This is just a convinience method it is
+ * also possible to use IGraph#add_vertices to add a single vertex.
+ *
+ * Returns 0 on success.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.add_vertex(5)
+ *
+ * Adds 1 extra vertex to this graph. IGraph will silently ignore attempts
+ * to add a vertex twice to the same graph.
+ */
+VALUE cIGraph_add_vertex(VALUE self, VALUE v){
+
+  igraph_t *graph;
+  VALUE vertex;
+  VALUE object_h;
+  VALUE id_h;
+  int vertex_n;
+  int code = 0;
+  int length;
+
+  object_h = rb_iv_get(self,"@object_ids");
+  id_h     = rb_iv_get(self,"@id_objects");
+  length   = 1;
+  vertex_n = NUM2INT(rb_funcall(object_h,rb_intern("length"),0));
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Loop through objects in vertex array
+  if(rb_funcall(object_h,rb_intern("has_key?"),1,v)){
+    //If @vertices includes this vertex then raise an error
+    //Silently ignore
+    //rb_raise(cIGraphError, "Vertex already added to graph");
+    length--;
+  } else {
+    //otherwise add a new entry to Hash
+    rb_hash_aset(object_h,v,INT2NUM(vertex_n));
+    rb_hash_aset(id_h,    INT2NUM(vertex_n),v);
+    vertex_n++;
+  }
+
+  if(length != 0)
+    code = igraph_add_vertices(graph,length,0);
+
+  return INT2NUM(code);
+
+}