igraph 0.1.1 → 0.3

data/ext/cIGraph_layout.c

@@ -0,0 +1,77 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.layout_random -> IGraphMatrix
+ * 
+ * Returns a random layout
+ */
+VALUE cIGraph_layout_random(VALUE self){
+
+  igraph_t *graph;
+  igraph_matrix_t *res = malloc(sizeof(igraph_matrix_t));
+
+  Data_Get_Struct(self, igraph_t, graph);
+ 
+  igraph_matrix_init(res,0,0);
+  igraph_layout_random(graph,res);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_random -> IGraphMatrix
+ * 
+ * Returns a layout with nodes laid out around a circle.
+ */
+VALUE cIGraph_layout_circle(VALUE self){
+
+  igraph_t *graph;
+  igraph_matrix_t *res = malloc(sizeof(igraph_matrix_t));
+
+  Data_Get_Struct(self, igraph_t, graph);
+ 
+  igraph_matrix_init(res,0,0);
+  igraph_layout_circle(graph,res);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_random -> IGraphMatrix
+ * 
+ * Places the vertices on a plane according to the Fruchterman-Reingold 
+ * algorithm.
+ *
+ * This is a force-directed layout, see Fruchterman, T.M.J. and Reingold, 
+ * E.M.: Graph Drawing by Force-directed Placement. Software -- Practice and 
+ * Experience, 21/11, 1129--1164, 1991.
+ */
+VALUE cIGraph_layout_fruchterman_reingold(VALUE self,
+					  VALUE niter,
+					  VALUE maxdelta,
+					  VALUE area,
+					  VALUE coolexp,
+					  VALUE repulserad,
+					  VALUE use_seed){
+
+  igraph_t *graph;
+  igraph_matrix_t *res = malloc(sizeof(igraph_matrix_t));
+
+  Data_Get_Struct(self, igraph_t, graph);
+ 
+  igraph_matrix_init(res,0,0);
+  igraph_layout_fruchterman_reingold(graph,res,
+				     NUM2INT(niter),
+				     NUM2DBL(maxdelta),
+				     NUM2DBL(area),
+				     NUM2DBL(coolexp),
+				     NUM2DBL(repulserad),
+				     use_seed == Qtrue ? 1: 0);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}

data/ext/cIGraph_matrix.c

@@ -0,0 +1,241 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+//Classes
+VALUE cIGraphMatrix;
+
+void cIGraph_matrix_free(void *p){
+  igraph_matrix_destroy(p);
+}
+
+VALUE cIGraph_matrix_alloc(VALUE klass){
+
+  igraph_matrix_t *m = malloc(sizeof(igraph_matrix_t));
+  VALUE obj;
+
+  igraph_matrix_init(m, 0, 0);
+
+  obj = Data_Wrap_Struct(klass, 0, cIGraph_matrix_free, m);
+
+  return obj;
+  
+}
+
+/* Document-method: initialize_copy
+ *
+ * Internal method for copying IGraph objects.
+ */
+VALUE cIGraph_matrix_init_copy(VALUE copy, VALUE orig){
+
+  igraph_matrix_t *orig_m;
+  igraph_matrix_t *copy_m;
+
+  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_matrix_t, copy_m); 
+  Data_Get_Struct(orig, igraph_matrix_t, orig_m);
+
+  igraph_matrix_copy(copy_m,orig_m);
+
+  return copy;
+
+}
+
+/* call-seq:
+ *   IGraphMatrix.new([[x,y,...],...]) -> IGraphMatrix
+ *
+ * Creates a new IGraphMatrix object. The argument should be an Array of
+ * Arrays which each contain the data for a row of the matrix. 
+ */
+VALUE cIGraph_matrix_initialize(int argc, VALUE *argv, VALUE self){
+
+  igraph_matrix_t *m;
+  VALUE rows;
+  int nrows;
+  int ncols;
+  int i;
+  int j;
+
+  rb_scan_args(argc,argv,"0*", &rows);
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+
+  nrows = RARRAY(rows)->len;
+  ncols = RARRAY(RARRAY(rows)->ptr[0])->len;
+
+  igraph_matrix_resize(m, nrows, ncols);
+
+  //Loop through rows
+  for (i=0; i<nrows; i++) {
+    for (j=0; j<ncols; j++){
+      MATRIX(*m,i,j) = NUM2DBL(RARRAY(RARRAY(rows)->ptr[i])->ptr[j]);
+    }
+  }
+
+  return self;
+
+}
+
+/* call-seq:
+ *   matrix[i,j] -> Float
+ *
+ * Returns the value stored at row i and column j.
+ */
+VALUE cIGraph_matrix_get(VALUE self, VALUE i, VALUE j){
+
+  igraph_matrix_t *m;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+  return rb_float_new(MATRIX(*m,NUM2INT(i),NUM2INT(j)));
+
+}
+
+/* call-seq:
+ *   matrix[i,j]= -> Float
+ *
+ * Sets the value stored at row i and column j.
+ */
+VALUE cIGraph_matrix_set(VALUE self, VALUE i, VALUE j, VALUE x){
+
+  igraph_matrix_t *m;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+  MATRIX(*m,NUM2INT(i),NUM2INT(j)) = NUM2DBL(x);
+  return x;
+
+}
+
+/* call-seq:
+ *   matrix.each{|v| } -> nil
+ *
+ * Iterates through each value in the matrix.
+ */
+VALUE cIGraph_matrix_each(VALUE self){
+
+  igraph_matrix_t *m;
+  int i;
+  int j;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+  
+  for(i=0;i < m->nrow;i++){
+    for(j=0;j < m->ncol;j++){
+      rb_yield(rb_float_new(MATRIX(*m,i,j)));
+    }
+  }
+
+  return Qnil;
+
+}
+
+/* call-seq:
+ *   matrix.size -> Integer
+ *
+ * Returns the number of elements in the matrix.
+ */
+VALUE cIGraph_matrix_size(VALUE self){
+
+  igraph_matrix_t *m;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+  return LONG2FIX(igraph_matrix_size(m));
+
+}
+
+/* call-seq:
+ *   matrix.nrow -> Integer
+ *
+ * Returns the number of rows in the matrix.
+ */
+VALUE cIGraph_matrix_nrow(VALUE self){
+
+  igraph_matrix_t *m;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+  return LONG2FIX(igraph_matrix_nrow(m));
+
+}
+
+/* call-seq:
+ *   matrix.ncol -> Integer
+ *
+ * Returns the number of columns in the matrix.
+ */
+VALUE cIGraph_matrix_ncol(VALUE self){
+
+  igraph_matrix_t *m;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+  return LONG2FIX(igraph_matrix_ncol(m));
+
+}
+
+/* call-seq:
+ *   matrix.max -> Float
+ *
+ * Returns the value of the maximum element in the matrix.
+ */
+VALUE cIGraph_matrix_max(VALUE self){
+
+  igraph_matrix_t *m;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+  return rb_float_new(igraph_matrix_max(m));
+
+}
+
+/* call-seq:
+ *   matrix * matrix -> IGraphMatrix
+ *
+ * Multiples two IGraphMatrix objects together
+ */
+VALUE cIGraph_matrix_multiply(VALUE self, VALUE x){
+
+  igraph_matrix_t *m;
+  igraph_matrix_t *n = malloc(sizeof(igraph_matrix_t));
+  VALUE nobj;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+
+  igraph_matrix_copy(n,m);
+  igraph_matrix_multiply(n, NUM2DBL(x));
+
+  nobj = Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, n);
+
+  return nobj;
+
+}
+
+/* call-seq:
+ *   matrix.to_a -> Array
+ *
+ * Returns the matrix represented as an Array of Arrays.
+ */
+VALUE cIGraph_matrix_toa(VALUE self){
+
+  igraph_matrix_t *m;
+  int i;
+  int j;
+  VALUE a = rb_ary_new();
+  VALUE row;
+
+  Data_Get_Struct(self, igraph_matrix_t, m);
+
+  for(i=0;i < m->nrow;i++){
+    row = rb_ary_new();
+    for(j=0;j < m->ncol;j++){
+      rb_ary_push(row,rb_float_new(MATRIX(*m,i,j)));
+    }
+    rb_ary_push(a,row);
+  }
+
+  return a;
+
+}
+  

data/ext/cIGraph_selectors.c

@@ -18,7 +18,7 @@ VALUE cIGraph_all_v(VALUE self){
   igraph_t *graph;  
 
   Data_Get_Struct(self, igraph_t, graph);
-  return rb_funcall(rb_iv_get(self,"@object_ids"),rb_intern("keys"),0);
+  return ((VALUE*)graph->attr)[0];
 
 }
 
@@ -67,27 +67,115 @@ VALUE cIGraph_adj_v(VALUE self, VALUE v, VALUE mode){
 
 }
 
+/* call-seq:
+ *   graph.noadjacent_vertices(v,mode) -> Array
+ *
+ * Returns all non-neighboring vertices of a given vertex (v). The mode 
+ * argument controls the type of neighboring vertics not to select. Possible 
+ * values: IGRAPH_OUT, all vertices will be selected except those to which 
+ * there is a directed edge from vid. IGRAPH_IN, all vertices will be 
+ * selected except those from which there is a directed edge to vid. 
+ * IGRAPH_ALL, all vertices will be selected except those from or to which 
+ * there is a directed edge to or from vid.
+ */
+
 VALUE cIGraph_nonadj_v(VALUE self, VALUE v, VALUE mode){
 
-  return Qnil;
+  igraph_t *graph;  
+  igraph_integer_t pnode;
+  VALUE nonadjacent = rb_ary_new();
+  igraph_neimode_t pmode = NUM2INT(mode);  
+  igraph_vs_t vs;
+  igraph_vit_t vit;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  pnode = cIGraph_get_vertex_id(self,v);
+
+  igraph_vs_nonadj(&vs,pnode,pmode);
+  igraph_vit_create(graph, vs, &vit);
+
+  while(!IGRAPH_VIT_END(vit)) {
+    rb_ary_push(nonadjacent,cIGraph_get_vertex_object(self,IGRAPH_VIT_GET(vit)));
+    IGRAPH_VIT_NEXT(vit);
+  }
+
+  igraph_vit_destroy(&vit);
+  igraph_vs_destroy(&vs);  
+
+  return nonadjacent;  
 
 }
 
+/* call-seq:
+ *   graph.edges(mode) -> Array
+ *
+ * Returns an Array of all edge ids in the graph. The mode argument specifies 
+ * the order the eids are returned. Possible values: IGRAPH_EDGEORDER_ID, 
+ * edge id order. IGRAPH_EDGEORDER_FROM, vertex id order, the id of the 
+ * source vertex counts for directed graphs. The order of the adjacent edges 
+ * of a given vertex is arbitrary. IGRAPH_EDGEORDER_TO, vertex id order, the 
+ * id of the target vertex counts for directed graphs. The order of the 
+ * adjacent edges of a given vertex is arbitrary. For undirected graph the 
+ * latter two is the same.
+ */
 VALUE cIGraph_all_e(VALUE self, VALUE mode){
 
-  return Qnil;
+  igraph_t *graph;
+  igraph_es_t es;
+  igraph_eit_t eit;
+  igraph_edgeorder_type_t pmode = NUM2INT(mode);  
+  VALUE edge_ids = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_es_all(&es,pmode);
+  igraph_eit_create(graph, es, &eit);
+
+  while(!IGRAPH_EIT_END(eit)) {
+    rb_ary_push(edge_ids,INT2NUM(IGRAPH_EIT_GET(eit)));
+    IGRAPH_EIT_NEXT(eit);
+  }
+
+  igraph_eit_destroy(&eit);
+  igraph_es_destroy(&es);  
+
+  return edge_ids;  
+  
 
 }
 
+/* call-seq:
+ *   graph.adjacent_edges(v,mode) -> Array
+ *
+ * Returns an Array of the eids of the adjacent edges of a vertex (v). The 
+ * mode argument gives the type of edges to select. Possible values: 
+ * IGRAPH_OUT, outgoing edges IGRAPH_IN, incoming edges IGRAPH_ALL, all edges
+ */
 VALUE cIGraph_adj_e(VALUE self, VALUE v, VALUE mode){
 
-  return Qnil;
+  igraph_t *graph;  
+  igraph_es_t es;
+  igraph_eit_t eit;
 
-}
+  VALUE adjacent = rb_ary_new();
 
-VALUE cIGraph_nonadj_e(VALUE self, VALUE v, VALUE mode){
+  Data_Get_Struct(self, igraph_t, graph);
 
-  return Qnil;
+  igraph_es_none(&es);
+  igraph_es_adj(&es,cIGraph_get_vertex_id(self,v),NUM2INT(mode));
+  igraph_eit_create(graph, es, &eit);
+
+  while(!IGRAPH_EIT_END(eit)) {
+    rb_ary_push(adjacent,INT2NUM(IGRAPH_EIT_GET(eit)));
+    IGRAPH_EIT_NEXT(eit);
+  }
+
+  igraph_eit_destroy(&eit);
+  igraph_es_destroy(&es);  
+
+  return adjacent;
 
 }
 
+

data/ext/cIGraph_shortest_paths.c

@@ -2,6 +2,17 @@
 #include "ruby.h"
 #include "cIGraph.h"
 
+/* call-seq:
+ *   graph.shortest_paths(varray,mode) -> Array
+ *
+ * Calculates the length of the shortest paths from each of the vertices in
+ * the varray Array to all of the other vertices in the graph. The result
+ * is returned as an Array of Array. Each top-level Array contains the results
+ * for a vertex in the varray Array. Each entry in the Array is the path length
+ * to another vertex in the graph in vertex order (the order the vertices were
+ * added to the graph. (This should probalby be changed to give a Hash of Hash
+ * to allow easier look up.)
+ */
 VALUE cIGraph_shortest_paths(VALUE self, VALUE from, VALUE mode){
 
   igraph_t *graph;
@@ -49,6 +60,17 @@ VALUE cIGraph_shortest_paths(VALUE self, VALUE from, VALUE mode){
 
 }
 
+/* call-seq:
+ *   graph.get_shortest_paths(from,to_array,mode) -> Array
+ *
+ * Calculates the paths from the vertex specified as from to each vertex in the
+ * to_array Array. Returns an Array of Arrays. Each top level Array represents
+ * a path and each entry in each Array is a vertex on the path. mode
+ * represents the type of shortest paths to be calculated: IGraph::OUT
+ * the outgoing paths are calculated. IGraph::IN the incoming paths are 
+ * calculated. IGraph::ALL the directed graph is considered as an undirected 
+ * one for the computation. 
+ */
 VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
 
   igraph_t *graph;
@@ -70,7 +92,7 @@ VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
 
   Data_Get_Struct(self, igraph_t, graph);
 
-  n_paths = NUM2INT(rb_funcall(to,rb_intern("length"),0));
+  n_paths = RARRAY(to)->len;
 
   //vector to hold the results of the calculations
   igraph_vector_ptr_init(&res,0);
@@ -93,8 +115,8 @@ VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
   for(i=0; i<n_paths; i++){
     path = rb_ary_new();
     rb_ary_push(matrix,path);
+    path_v = VECTOR(res)[i];
     for(j=0; j<igraph_vector_size(VECTOR(res)[i]); j++){
-      path_v = VECTOR(res)[i];
       rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(*path_v)[j]));
     }
   }
@@ -110,3 +132,175 @@ VALUE cIGraph_get_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
   return matrix;
 
 }
+
+/* call-seq:
+ *   graph.get_all_shortest_paths(from,mode) -> Array
+ *
+ * Calculates the paths from the vertex specified as from to each vertex 
+ * in the to_array Arrayevery other. Returns an Array of Arrays. Each top 
+ * level Array represents a path and each entry in each Array is a vertex on 
+ * the path. mode represents the type of shortest paths to be calculated: 
+ * IGraph::OUT the outgoing paths are calculated. IGraph::IN the incoming 
+ * paths are calculated. IGraph::ALL the directed graph is considered as an 
+ * undirected one for the computation. In contrast to 
+ * IGraph#get_shortest_paths all possible shortest paths are reported here. 
+ */
+VALUE cIGraph_get_all_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
+
+  igraph_t *graph;
+
+  igraph_integer_t from_vid;
+  igraph_neimode_t pmode = NUM2INT(mode);
+
+  igraph_vs_t to_vids;
+  igraph_vector_t to_vidv;
+
+  igraph_vector_ptr_t res;
+  igraph_vector_t *path_v;
+
+  int i;
+  int j;
+  VALUE path;
+  VALUE matrix = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //vector to hold the results of the calculations
+  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
+  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_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();
+    rb_ary_push(matrix,path);
+    for(j=0; j<igraph_vector_size(VECTOR(res)[i]); j++){
+      path_v = VECTOR(res)[i];
+      rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(*path_v)[j]));
+    }
+  }
+
+  for(i=0;i<igraph_vector_ptr_size(&res);i++){
+    igraph_vector_destroy(VECTOR(res)[i]);
+  }
+
+  igraph_vector_ptr_destroy(&res);
+
+  return matrix;
+
+}
+
+/* call-seq:
+ *   graph.average_path_length(directed,uncon) -> Float
+ *
+ * Calculates the average geodesic length in a graph. directed should be a
+ * boolean specifying whether to consider directed paths. unconn is another
+ * boolean specifying what to do about unconnected graphs. If TRUE the 
+ * average of the geodesics within the components will be returned, 
+ * otherwise the number of vertices is used for the length of non-existing 
+ * geodesics. (The rationale behind this is that this is always longer than 
+ * the longest possible geodesic in a graph.)
+ */
+VALUE cIGraph_average_path_length(VALUE self, VALUE directed, VALUE unconn){
+
+  igraph_t *graph;
+  igraph_bool_t directed_b = 0;
+  igraph_bool_t unconn_b   = 0;
+  igraph_real_t res;
+
+  if(directed)
+    directed_b = 1;
+  if(unconn)
+    unconn_b = 1;
+  
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_average_path_length(graph,&res,directed_b,unconn_b);
+
+  return rb_float_new(res);
+
+}
+
+/* call-seq:
+ *   graph.diameter(directed,uncon) -> Array
+ *
+ * Returns the longest path in the graph. directed should be a
+ * boolean specifying whether to consider directed paths. unconn is another
+ * boolean specifying what to do about unconnected graphs. If TRUE the 
+ * average of the geodesics within the components will be returned, 
+ * otherwise the number of vertices is used for the length of non-existing 
+ * geodesics. (The rationale behind this is that this is always longer than 
+ * the longest possible diamter in a graph.)
+ */
+VALUE cIGraph_diameter(VALUE self, VALUE directed, VALUE unconn){
+
+  igraph_t *graph;
+  igraph_bool_t directed_b = 0;
+  igraph_bool_t unconn_b   = 0;
+  igraph_vector_t res;
+  int i;
+  VALUE path = rb_ary_new();
+
+  if(directed)
+    directed_b = 1;
+  if(unconn)
+    unconn_b = 1;
+  
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //vector to hold the results of the calculations
+  igraph_vector_init(&res,0);
+
+  igraph_diameter(graph,NULL,NULL,NULL,&res,directed_b,unconn_b);
+
+  for(i=0; i<igraph_vector_size(&res); i++){
+    rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&res);
+
+  return path;
+
+}
+
+/* call-seq:
+ *   graph.diameter(directed,uncon) -> Array
+ *
+ * Returns the shortest cycle in the graph. directed should be a
+ * boolean specifying whether to consider directed paths. unconn is another
+ * boolean specifying what to do about unconnected graphs. If TRUE the 
+ * average of the geodesics within the components will be returned, 
+ * otherwise the number of vertices is used for the length of non-existing 
+ * geodesics. (The rationale behind this is that this is always longer than 
+ * the longest possible diamter in a graph.)
+ */
+VALUE cIGraph_girth(VALUE self){
+
+  igraph_t *graph;
+  igraph_vector_t res;
+  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_girth(graph,NULL,&res);
+
+  for(i=0; i<igraph_vector_size(&res); i++){
+    rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&res);
+
+  return path;
+
+}