igraph 0.1.1 → 0.3

data/ext/cIGraph_centrality.c

@@ -0,0 +1,264 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.closeness(vs,mode) -> Array
+ *
+ * Returns an Array of closeness centrality measures for the vertices given in
+ * the vs Array. mode defines the type of shortest paths used for the 
+ * calculation
+ */
+VALUE cIGraph_closeness(VALUE self, VALUE vs, VALUE mode){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_t res;
+  int i;
+  VALUE closeness = rb_ary_new();
+
+  //vector to hold the results of the degree calculations
+  igraph_vector_init_int(&res,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_closeness(graph,&res,vids,pmode);
+
+  for(i=0;i<igraph_vector_size(&res);i++){
+    rb_ary_push(closeness,rb_float_new(VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return closeness;
+
+}
+
+/* call-seq:
+ *   graph.betweenness(vs,mode) -> Array
+ *
+ * Returns an Array of betweenness centrality measures for the vertices given 
+ * in the vs Array. mode defines whether directed paths or considered for 
+ * directed graphs.
+ */
+VALUE cIGraph_betweenness(VALUE self, VALUE vs, VALUE directed){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_bool_t dir = 0;
+  igraph_vector_t res;
+  int i;
+  VALUE betweenness = rb_ary_new();
+
+  if(directed == Qtrue)
+    dir = 1;
+
+  //vector to hold the results of the degree calculations
+  igraph_vector_init_int(&res,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_betweenness(graph,&res,vids,dir);
+
+  for(i=0;i<igraph_vector_size(&res);i++){
+    rb_ary_push(betweenness,INT2NUM((int)VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return betweenness;
+
+}
+
+/* call-seq:
+ *   graph.edge_betweenness(mode) -> Array
+ *
+ * Returns an Array of betweenness centrality measures for the edges 
+ * in the graph. mode defines whether directed paths or considered for 
+ * directed graphs.
+ */
+VALUE cIGraph_edge_betweenness(VALUE self, VALUE directed){
+
+  igraph_t *graph;
+  igraph_bool_t dir = 0;
+  igraph_vector_t res;
+  int i;
+  VALUE betweenness = rb_ary_new();
+
+  if(directed == Qtrue)
+    dir = 1;
+
+  //vector to hold the results of the degree calculations
+  igraph_vector_init_int(&res,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_edge_betweenness(graph,&res,dir);
+
+  for(i=0;i<igraph_vector_size(&res);i++){
+    rb_ary_push(betweenness,INT2NUM((int)VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&res);
+
+  return betweenness;
+
+}
+
+/* call-seq:
+ *   graph.pagerank(vs,mode,niter,eps,damping) -> Array
+ *
+ * Returns an Array of PageRank measures for the vertices 
+ * in the graph. mode defines whether directed paths or considered for 
+ * directed graphs.
+ */
+VALUE cIGraph_pagerank(VALUE self, VALUE vs, VALUE directed, VALUE niter, VALUE eps, VALUE damping){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_vector_t res;
+  int i;
+  VALUE pagerank = rb_ary_new();
+  igraph_bool_t dir = 0;
+
+  if(directed == Qtrue)
+    dir = 1;
+
+  //vector to hold the results of the degree calculations
+  igraph_vector_init_int(&res,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_pagerank(graph,&res,vids,dir,
+		  NUM2INT(niter),NUM2DBL(eps),NUM2DBL(damping));
+
+  for(i=0;i<igraph_vector_size(&res);i++){
+    rb_ary_push(pagerank,rb_float_new(VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return pagerank;
+
+}
+
+/* call-seq:
+ *   graph.constraint(vs,weights) -> Array
+ *
+ * Returns an Array of constraint measures for the vertices 
+ * in the graph. Weights is an Array of weight measures for each edge.
+ */
+VALUE cIGraph_constraint(int argc, VALUE *argv, VALUE self){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_vector_t res;
+  igraph_vector_t *wght =  malloc(sizeof(igraph_vector_t));
+  int i;
+  VALUE constraints = rb_ary_new();
+  VALUE vs, weights;
+
+  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);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Convert an array of vertices to a vector of vertex ids
+  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;
+  } else {
+    for(i=0;i<RARRAY(weights)->len;i++){
+      igraph_vector_push_back(wght,NUM2DBL(RARRAY(weights)->ptr[i]));
+    }
+  }
+
+  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_vs_destroy(&vids);
+
+  free(wght);
+
+  return constraints;
+
+}
+
+
+/* call-seq:
+ *   graph.maxdegree(vs,mode,loops) -> Vertex
+ *
+ * Returns the vertex Object in the vs Array with the largest degree. 
+ * mode defines the type 
+ * of the degree. IGRAPH_OUT, out-degree, IGRAPH_IN, in-degree, IGRAPH_ALL, 
+ * total degree (sum of the in- and out-degree). This parameter is ignored 
+ * for undirected graphs. loops is a boolean gives whether the self-loops 
+ * should be counted. 
+ */
+VALUE cIGraph_maxdegree(VALUE self, VALUE vs, VALUE mode, VALUE loops){
+
+  igraph_t *graph;
+  igraph_bool_t loop = 0;
+  igraph_integer_t res;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+
+  if(loops == Qtrue)
+    loop = 1;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_maxdegree(graph,&res,vids,pmode,loop);
+
+  igraph_vector_destroy(&vidv);
+  igraph_vs_destroy(&vids);
+
+  return INT2NUM(res);
+
+}

data/ext/cIGraph_components.c

@@ -0,0 +1,154 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.subcomponent(v,mode) -> Array
+ *
+ * Returns an Array of vertices that are in the same component as the vertex v.
+ * mode defines the type of the component for directed graphs, possible 
+ * values: IGraph::OUT: the set of vertices reachable from the vertex, 
+ * IGraph::IN the set of vertices from which the vertex is reachable, 
+ * IGraph::ALL 	the graph is considered as an undirected graph. Note that 
+ * this is not the same as the union of the previous two. 
+ */
+VALUE cIGraph_subcomponent(VALUE self, VALUE v, VALUE mode){
+
+  igraph_t *graph;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_t neis;
+  int i;
+  VALUE component = rb_ary_new();
+
+  igraph_vector_init_int(&neis,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_subcomponent(graph, &neis, cIGraph_get_vertex_id(self,v), pmode);
+
+  for(i=0;i<igraph_vector_size(&neis);i++){
+    rb_ary_push(component,cIGraph_get_vertex_object(self,VECTOR(neis)[i]));
+  }
+
+  igraph_vector_destroy(&neis);
+
+  return component;  
+
+}
+
+/* call-seq:
+ *   graph.subgraph(vs) -> IGraph
+ *
+ * Returns an IGraph object containing the vertices defined in the Array vs.
+ */
+VALUE cIGraph_subgraph(VALUE self, VALUE vs){
+
+  igraph_t *graph;
+  igraph_t *n_graph = malloc(sizeof(igraph_t));
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+
+  VALUE n_graph_obj;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  //Convert an array of vertices to a vector of vertex ids
+  cIGraph_vertex_arr_to_id_vec(self,vs,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_subgraph(graph,n_graph,vids);
+
+  n_graph_obj = Data_Wrap_Struct(cIGraph, cIGraph_mark, cIGraph_free, n_graph);
+
+  igraph_vector_destroy(&vidv);
+  igraph_vs_destroy(&vids);
+
+  return n_graph_obj;
+
+}
+
+/* call-seq:
+ *   graph.clusters(mode) -> Array
+ *
+ * Calculates the (weakly or strongly) connected components in a graph.
+ * Returns an Array of Arrays of vertices. Each sub-Array is a graph component
+ */
+VALUE cIGraph_clusters(VALUE self, VALUE mode){
+
+  igraph_t *graph;
+  igraph_vector_t membership;
+  igraph_integer_t no;
+  VALUE components;
+  VALUE v,c;
+  int i;
+
+  igraph_vector_init_int(&membership,0);
+  
+  Data_Get_Struct(self, igraph_t, graph); 
+  
+  igraph_clusters(graph, &membership, NULL, &no, NUM2INT(mode));
+
+  components = rb_ary_new();
+  for(i=0;i<no;i++){
+    rb_ary_push(components,rb_ary_new());
+  }
+
+  for(i=0;i<igraph_vector_size(&membership);i++){
+    v = cIGraph_get_vertex_object(self, i);
+    c = rb_ary_entry(components,VECTOR(membership)[i]);
+    rb_ary_push(c,v);
+  }
+
+  igraph_vector_destroy(&membership);
+
+  return components;
+
+}
+
+/* call-seq:
+ *    graph.decompose(mode,maxcomp=-1,minelem=1) -> Array
+ * 
+ * Create separate graph for each component of a graph. Returns an Array
+ * of new IGraph object. mode specifies whether weakly and strongly connected 
+ * components are returned. Right now only the former is implemented. maxcomp
+ * limits the number of components returned. Leave at the default -1 to return
+ * all components. minelements specifies the minimum number of vertices a
+ * component should contain before it is returned. Default 1 returns all 
+ * components.
+ */
+VALUE cIGraph_decompose(int argc, VALUE *argv, VALUE self){
+
+  igraph_t *graph;
+  igraph_t *n_graph;
+  igraph_vector_ptr_t components;
+  VALUE mode,maxcomp, minelem, components_a;
+  VALUE n_graph_obj;
+  int i;
+
+  rb_scan_args(argc,argv,"12", &mode, &maxcomp, &minelem);
+
+  if(maxcomp == Qnil)
+    maxcomp = INT2NUM(-1);
+  if(minelem == Qnil)
+    minelem = INT2NUM(1);
+
+  igraph_vector_ptr_init(&components,0);
+  
+  Data_Get_Struct(self, igraph_t, graph); 
+  
+  igraph_decompose(graph, &components, NUM2INT(mode), NUM2INT(maxcomp), NUM2INT(minelem));
+
+  components_a = rb_ary_new();
+
+  for(i=0; i<igraph_vector_ptr_size(&components); i++){
+    n_graph = VECTOR(components)[i];
+    n_graph_obj = Data_Wrap_Struct(cIGraph, cIGraph_mark, cIGraph_free, n_graph);
+    rb_ary_push(components_a,n_graph_obj);
+  } 
+
+  igraph_vector_ptr_destroy(&components);
+
+  return components_a;
+
+}

data/ext/cIGraph_file.c

@@ -0,0 +1,213 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   IGraph.read_graph_edgelist(file,mode) -> IGraph
+ *
+ *  Reads an edge list from a File (or any IO) and creates a graph.
+ *
+ * This format is simply a series of even number integers separated by
+ * whitespace. The one edge (ie. two integers) per line format is thus not 
+ * required (but recommended for readability). Edges of directed graphs are 
+ * assumed to be in from, to order. 
+ */
+VALUE cIGraph_read_graph_edgelist(VALUE self, VALUE file, VALUE directed){
+
+  VALUE string;
+  FILE *stream;
+  VALUE new_graph;
+  VALUE v_ary;
+  igraph_t *graph;
+  igraph_bool_t directed_b = 0;
+
+  igraph_vs_t vs;
+  igraph_vit_t vit;
+
+  int vid;
+
+  if(directed)
+    directed_b = 1;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  string = rb_funcall(file, rb_intern("read"), 0);
+  stream = fmemopen(RSTRING(string)->ptr,RSTRING(string)->len, "r");
+
+  igraph_read_graph_edgelist(graph, stream, 0, directed_b);
+
+  fclose(stream);
+
+  igraph_vs_all(&vs);
+  igraph_vit_create(graph, vs, &vit);
+
+  v_ary =  ((VALUE*)graph->attr)[0];
+
+  while (!IGRAPH_VIT_END(vit)) {
+    vid = IGRAPH_VIT_GET(vit);
+    rb_ary_push(v_ary,INT2NUM(vid));
+    IGRAPH_VIT_NEXT(vit);
+  }
+  
+  igraph_vit_destroy(&vit);
+  igraph_vs_destroy(&vs);
+
+  return new_graph;
+
+}
+
+/* call-seq:
+ *   graph.write_graph_edgelist(file) -> Integer
+ *
+ *  Writes an edge list to an IO
+ *
+ * This format is simply a series of even number integers separated by
+ * whitespace. The one edge (ie. two integers) per line format is thus not 
+ * required (but recommended for readability). Edges of directed graphs are 
+ * assumed to be in from, to order. 
+ */
+VALUE cIGraph_write_graph_edgelist(VALUE self, VALUE file){
+
+  char *buf;
+  size_t size;
+  FILE *stream;
+  igraph_t *graph;
+  int e;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  stream = open_memstream(&buf,&size);
+  e = igraph_write_graph_edgelist(graph, stream);
+  fflush(stream);
+
+  rb_funcall(file, rb_intern("write"), 1, rb_str_new(buf,size));
+
+  fclose(stream);
+
+  return e;
+
+}
+
+/* call-seq:
+ *   IGraph.read_graph_graphml(file,index) -> IGraph
+ *
+ * Reads a graph from a GraphML file specified as the File object file.
+ *
+ * GraphML is an XML-based file format for representing various types of 
+ * graphs. Currently only the most basic import functionality is implemented 
+ * in igraph: it can read GraphML files without nested graphs and hyperedges. 
+ *
+ * If the GraphML file contains more than one graph, the one specified by 
+ * this index will be loaded. Indices start from zero, so supply zero here 
+ * if your GraphML file contains only a single graph.
+ */
+VALUE cIGraph_read_graph_graphml(VALUE self, VALUE file, VALUE index){
+
+  VALUE string;
+  FILE *stream;
+  VALUE new_graph;
+  igraph_t *graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  string = rb_funcall(file, rb_intern("read"), 0);
+  stream = fmemopen(RSTRING(string)->ptr,RSTRING(string)->len, "r");
+
+  igraph_read_graph_graphml(graph, stream, NUM2INT(index));
+
+  fclose(stream);
+
+  return new_graph;  
+
+}
+
+/* call-seq:
+ *   graph.write_graph_graphml(file) -> Integer
+ *
+ * Writes the graph to a File in GraphML format
+ *
+ * GraphML is an XML-based file format for representing various types of 
+ * graphs. See the GraphML Primer 
+ * (http://graphml.graphdrawing.org/primer/graphml-primer.html) for detailed 
+ * format description. 
+ */
+VALUE cIGraph_write_graph_graphml(VALUE self, VALUE file){
+
+  char *buf;
+  size_t size;
+  FILE *stream;
+  igraph_t *graph;
+  int e;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  stream = open_memstream(&buf,&size);
+  e = igraph_write_graph_graphml(graph, stream);
+  fflush(stream);
+
+  rb_funcall(file, rb_intern("write"), 1, rb_str_new(buf,size));
+
+  fclose(stream);
+
+  return e;
+
+}
+
+/* call-seq:
+ *   IGraph.read_graph_pajek(file) -> IGraph
+ *
+ * Reads a file in Pajek format
+ *
+ * Only a subset of the Pajek format is implemented. This is partially 
+ * because this format is not very well documented, but also because 
+ * igraph does not support some Pajek features, like multigraphs.
+ */
+VALUE cIGraph_read_graph_pajek(VALUE self, VALUE file){
+
+  VALUE string;
+  FILE *stream;
+  VALUE new_graph;
+  igraph_t *graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  string = rb_funcall(file, rb_intern("read"), 0);
+  stream = fmemopen(RSTRING(string)->ptr,RSTRING(string)->len, "r");
+
+  igraph_read_graph_pajek(graph, stream);
+
+  fclose(stream);
+
+  return new_graph;  
+
+}
+
+/* call-seq:
+ *   graph.write_graph_pajek(file) -> Integer
+ *
+ * Writes a graph to a file in Pajek format.
+ */
+VALUE cIGraph_write_graph_pajek(VALUE self, VALUE file){
+
+  char *buf;
+  size_t size;
+  FILE *stream;
+  igraph_t *graph;
+  int e;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  stream = open_memstream(&buf,&size);
+  e = igraph_write_graph_pajek(graph, stream);
+  fflush(stream);
+
+  rb_funcall(file, rb_intern("write"), 1, rb_str_new(buf,size));
+
+  fclose(stream);
+
+  return e;
+
+}