igraph 0.3.2 → 0.3.3

data/ext/cIGraph_generators_random.c

@@ -0,0 +1,72 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+VALUE cIGraph_grg_game(VALUE self, VALUE nodes, VALUE radius, VALUE torus){
+
+  igraph_t *graph;
+  VALUE new_graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  igraph_destroy(graph);
+  igraph_grg_game(graph, NUM2INT(nodes), NUM2DBL(radius), 
+		  torus == Qtrue ? 1: 0);
+
+  return new_graph;
+
+}
+
+VALUE cIGraph_barabasi_game(VALUE self, VALUE nodes, VALUE m, VALUE outpref, VALUE directed){
+
+  igraph_t *graph;
+  VALUE new_graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  igraph_destroy(graph);
+  igraph_barabasi_game(graph, NUM2INT(nodes), NUM2INT(m), NULL, 
+		       outpref == Qtrue ? 1: 0, directed == Qtrue ? 1: 0);
+
+  return new_graph;
+
+}
+
+VALUE cIGraph_nonlinear_barabasi_game(VALUE self, VALUE nodes, VALUE power, VALUE m, VALUE outpref, VALUE zeroappeal, VALUE directed){
+
+  igraph_t *graph;
+  VALUE new_graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  igraph_destroy(graph);
+  igraph_nonlinear_barabasi_game(graph, NUM2INT(nodes), NUM2DBL(power),
+				  NUM2INT(m), NULL, 
+				  outpref == Qtrue ? 1: 0,
+				  NUM2DBL(zeroappeal),
+				  directed == Qtrue ? 1: 0);
+
+  return new_graph;
+
+}
+
+VALUE cIGraph_erdos_renyi_game(VALUE self, VALUE type, VALUE nodes, VALUE mp, VALUE directed, VALUE loops){
+
+  igraph_t *graph;
+  VALUE new_graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  igraph_destroy(graph);
+  igraph_erdos_renyi_game(graph, NUM2INT(type), NUM2INT(nodes),
+			  NUM2DBL(mp), 
+			  directed == Qtrue ? 1: 0,
+			  loops == Qtrue ? 1: 0);
+
+  return new_graph;
+
+}

data/ext/cIGraph_independent_vertex_sets.c

@@ -0,0 +1,182 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.independent_vertex_sets(min_size,max_size) -> Array
+ *
+ * Find all independent vertex sets in a graph
+ *
+ * A vertex set is considered independent if there are no edges between them.
+ *
+ * If you are interested in the size of the largest independent vertex set, 
+ * use IGraph#independence_number() instead.
+ */
+
+VALUE cIGraph_independent_vertex_sets(VALUE self, VALUE min, VALUE max){
+
+  igraph_t *graph;
+  igraph_vector_ptr_t res;
+  igraph_vector_t *vec;
+  int i;
+  int j;
+  VALUE independent_vertex_set;
+  VALUE object;
+  VALUE independent_vertex_sets = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  igraph_independent_vertex_sets(graph, &res, NUM2INT(min), NUM2INT(max));
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    independent_vertex_set = rb_ary_new();
+    rb_ary_push(independent_vertex_sets,independent_vertex_set);
+    vec = VECTOR(res)[i];
+    for(j=0; j<igraph_vector_size(vec); j++){
+      vec = VECTOR(res)[i];
+      object = cIGraph_get_vertex_object(self,VECTOR(*vec)[j]);
+      rb_ary_push(independent_vertex_set,object);
+    }
+  }
+
+  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);
+
+  return independent_vertex_sets;
+  
+}
+
+/* call-seq:
+ *   graph.largest_independent_vertex_sets() -> Array
+ *
+ * Finds the largest independent vertex set(s) in a graph.
+
+ * An independent vertex set is largest if there is no other independent 
+ * vertex set with more vertices in the graph. 
+ */
+
+VALUE cIGraph_largest_independent_vertex_sets(VALUE self){
+
+  igraph_t *graph;
+  igraph_vector_ptr_t res;
+  igraph_vector_t *vec;
+  int i;
+  int j;
+  VALUE independent_vertex_set;
+  VALUE object;
+  VALUE independent_vertex_sets = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  igraph_largest_independent_vertex_sets(graph, &res);
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    independent_vertex_set = rb_ary_new();
+    rb_ary_push(independent_vertex_sets,independent_vertex_set);
+    vec = VECTOR(res)[i];
+    for(j=0; j<igraph_vector_size(vec); j++){
+      vec = VECTOR(res)[i];
+      object = cIGraph_get_vertex_object(self,VECTOR(*vec)[j]);
+      rb_ary_push(independent_vertex_set,object);
+    }
+  }
+
+  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);
+
+  return independent_vertex_sets;
+  
+}
+
+/* call-seq:
+ *   graph.maximal_independent_vertex_sets() -> Array
+ *
+ * Find all maximal independent vertex sets of a graph
+ *
+ * A maximal independent vertex set is an independent vertex set which can't 
+ * be extended any more by adding a new vertex to it.
+ *
+ * The algorithm used here is based on the following paper: S. Tsukiyama, 
+ * M. Ide, H. Ariyoshi and I. Shirawaka. A new algorithm for generating all 
+ * the maximal independent sets. SIAM J Computing, 6:505--517, 1977.
+ *
+ * The implementation was originally written by Kevin O'Neill and modified 
+ * by K M Briggs in the Very Nauty Graph Library. I simply re-wrote it to 
+ * use igraph's data structures.
+ *
+ * If you are interested in the size of the largest independent vertex set, 
+ * use IGraph#independence_number() instead. 
+ */
+
+VALUE cIGraph_maximal_independent_vertex_sets(VALUE self){
+
+  igraph_t *graph;
+  igraph_vector_ptr_t res;
+  igraph_vector_t *vec;
+  int i;
+  int j;
+  VALUE independent_vertex_set;
+  VALUE object;
+  VALUE independent_vertex_sets = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  igraph_maximal_independent_vertex_sets(graph, &res);
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    independent_vertex_set = rb_ary_new();
+    rb_ary_push(independent_vertex_sets,independent_vertex_set);
+    vec = VECTOR(res)[i];
+    for(j=0; j<igraph_vector_size(vec); j++){
+      vec = VECTOR(res)[i];
+      object = cIGraph_get_vertex_object(self,VECTOR(*vec)[j]);
+      rb_ary_push(independent_vertex_set,object);
+    }
+  }
+
+  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);
+
+  return independent_vertex_sets;
+  
+}
+
+/* call-seq:
+ *   graph.independence_number() -> Integer
+ *
+ * Find the independence number of the graph
+ *
+ * The independence number of a graph is the cardinality of the largest 
+ * independent vertex set. 
+ */
+
+VALUE cIGraph_independence_number(VALUE self){
+
+  igraph_t *graph;
+  igraph_integer_t res;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_independence_number(graph, &res);
+
+  return INT2NUM(res);
+  
+}

data/ext/cIGraph_isomorphism.c

@@ -0,0 +1,137 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.isomorphic(graph) -> True/False
+ *
+ * Decides whether two graphs are isomorphic
+ *
+ * From Wikipedia: The graph isomorphism problem or GI problem is the graph 
+ * theory problem of determining whether, given two graphs G1 and G2, it is 
+ * possible to permute (or relabel) the vertices of one graph so that it is 
+ * equal to the other. Such a permutation is called a graph isomorphism. 
+ */
+VALUE cIGraph_isomorphic(VALUE self, VALUE g){
+
+  igraph_bool_t res = 0;
+  igraph_t *graph;
+  igraph_t *graph2;
+
+  Data_Get_Struct(self, igraph_t, graph);
+  Data_Get_Struct(g,    igraph_t, graph2);
+
+  IGRAPH_CHECK(igraph_isomorphic(graph,graph2,&res));
+
+  return res == 0 ? Qfalse : Qtrue;
+
+}
+
+/* call-seq:
+ *   graph.isomorphic_vf2(graph) -> True/False
+ *
+ * Decides whether two graphs are isomorphic
+ *
+ * This function is an implementation of the VF2 isomorphism algorithm, 
+ * see P. Foggia, C. Sansone, M. Vento, An Improved algorithm for matching 
+ * large graphs, Prof. of the 3rd IAPR-TC-15 International Workshop on 
+ * Graph-based Representations, Italy, 2001.
+ */
+VALUE cIGraph_isomorphic_vf2(VALUE self, VALUE g){
+
+  igraph_bool_t res = 0;
+  igraph_t *graph;
+  igraph_t *graph2;
+
+  Data_Get_Struct(self, igraph_t, graph);
+  Data_Get_Struct(g,    igraph_t, graph2);
+
+  IGRAPH_CHECK(igraph_isomorphic_vf2(graph,graph2,&res));
+
+  return res == 0 ? Qfalse : Qtrue;
+
+}
+
+/* call-seq:
+ *   graph.isoclass() -> Integer
+ *
+ *  Determine the isomorphism class of a graph
+ *
+ * All graphs with a given number of vertices belong to a number of 
+ * isomorpism classes, with every graph in a given class being isomorphic 
+ * to each other.
+ *
+ * This function gives the isomorphism class (a number) of a graph. Two 
+ * graphs have the same isomorphism class if and only if they are isomorphic.
+ *
+ * The first isomorphism class is numbered zero and it is the empty graph, 
+ * the last isomorphism class is the full graph. The number of isomorphism 
+ * class for directed graphs with three vertices is 16 (between 0 and 15), 
+ * for undirected graph it is only 4. For graphs with four vertices it is 
+ * 218 (directed) and 11 (undirected). 
+ */
+VALUE cIGraph_isoclass(VALUE self){
+
+  int res = 0;
+  igraph_t *graph;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  IGRAPH_CHECK(igraph_isoclass(graph,&res));
+
+  return INT2NUM(res);
+
+}
+
+/* call-seq:
+ *   graph.isoclass_subgraph(vs) -> Integer
+ *
+ * Determine the isomorphism class of a subgraph given by the vertices given
+ * in the Array vs.
+ *
+ */
+VALUE cIGraph_isoclass_subgraph(VALUE self, VALUE vs){
+
+  int res = 0;
+  igraph_t *graph;
+  igraph_vector_t vidv;
+
+  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);
+
+  IGRAPH_CHECK(igraph_isoclass_subgraph(graph,&vidv,&res));
+
+  igraph_vector_destroy(&vidv);
+
+  return INT2NUM(res);
+
+}
+
+/* call-seq:
+ *   IGraph.isoclass_create(vn,iso,dir) -> IGraph
+ * 
+ * Creates a graph with the number of vertices given by vn from the given 
+ * isomorphism class iso and the direction boolean dir.
+ *
+ * This function is implemented only for graphs with three or four vertices.
+ */
+VALUE cIGraph_isoclass_create(VALUE self, VALUE vn, VALUE iso, VALUE dir){
+
+  igraph_t *graph;
+  VALUE new_graph;
+  igraph_bool_t dir_b = 0;
+
+  if(dir)
+    dir_b = 1;
+
+  new_graph = cIGraph_alloc(cIGraph);  
+  Data_Get_Struct(new_graph, igraph_t, graph);
+
+  IGRAPH_CHECK(igraph_isoclass_create(graph,NUM2INT(vn),NUM2INT(iso),dir_b));
+
+  return new_graph;
+
+}

data/ext/cIGraph_layout.c

@@ -22,7 +22,7 @@ VALUE cIGraph_layout_random(VALUE self){
 }
 
 /* call-seq:
- *   graph.layout_random -> IGraphMatrix
+ *   graph.layout_circle -> IGraphMatrix
  * 
  * Returns a layout with nodes laid out around a circle.
  */
@@ -41,7 +41,7 @@ VALUE cIGraph_layout_circle(VALUE self){
 }
 
 /* call-seq:
- *   graph.layout_random -> IGraphMatrix
+ *   graph.layout_fruchterman_reingold -> IGraphMatrix
  * 
  * Places the vertices on a plane according to the Fruchterman-Reingold 
  * algorithm.
@@ -75,3 +75,175 @@ VALUE cIGraph_layout_fruchterman_reingold(VALUE self,
   return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
 
 }
+
+/* call-seq:
+ *   graph.layout_kamada_kawai -> IGraphMatrix
+ * 
+ * Places the vertices on a plane according the Kamada-Kawai algorithm.
+ *
+ * This is a force directed layout, see Kamada, T. and Kawai, S.: An 
+ * Algorithm for Drawing General Undirected Graphs. Information Processing 
+ * Letters, 31/1, 7--15, 1989.
+ */
+VALUE cIGraph_layout_kamada_kawai(VALUE self,
+				  VALUE niter,
+				  VALUE sigma,
+				  VALUE initemp,
+				  VALUE coolexp,
+				  VALUE kkconst){
+
+  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_kamada_kawai(graph,res,
+			     NUM2INT(niter),
+			     NUM2DBL(sigma),
+			     NUM2DBL(initemp),
+			     NUM2DBL(coolexp),
+			     NUM2DBL(kkconst));
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_reingold_tilford -> IGraphMatrix
+ * 
+ * Reingold-Tilford layout for tree graphs
+ *
+ * Arranges the nodes in a tree where the given node is used as the root. 
+ * The tree is directed downwards and the parents are centered above its 
+ * children. For the exact algorithm, see:
+ *
+ * Reingold, E and Tilford, J: Tidier drawing of trees. IEEE Trans. Softw. 
+ * Eng., SE-7(2):223--228, 1981
+ *
+ * If the given graph is not a tree, a breadth-first search is executed 
+ * first to obtain a possible spanning tree.
+ */
+VALUE cIGraph_layout_reingold_tilford(VALUE self,
+				      VALUE root){		
+
+  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_reingold_tilford(graph,res,
+				 cIGraph_get_vertex_id(self, root));
+  
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_reingold_tilford_circular -> IGraphMatrix
+ * 
+ * Reingold-Tilford layout for tree graphs, drawn in a circular style
+ *
+ * Arranges the nodes in a tree where the given node is used as the root. 
+ * The tree is directed downwards and the parents are centered above its 
+ * children. For the exact algorithm, see:
+ *
+ * Reingold, E and Tilford, J: Tidier drawing of trees. IEEE Trans. Softw. 
+ * Eng., SE-7(2):223--228, 1981
+ *
+ * If the given graph is not a tree, a breadth-first search is executed 
+ * first to obtain a possible spanning tree.
+ */
+VALUE cIGraph_layout_reingold_tilford_circular(VALUE self,
+					       VALUE root){		
+
+  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_reingold_tilford_circular(graph,res,
+					  cIGraph_get_vertex_id(self, root));
+  
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_grid_fruchterman_reingold -> 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_grid_fruchterman_reingold(VALUE self,
+					       VALUE niter,
+					       VALUE maxdelta,
+					       VALUE area,
+					       VALUE coolexp,
+					       VALUE repulserad,
+					       VALUE cellsize,
+					       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_grid_fruchterman_reingold(graph,res,
+					  NUM2INT(niter),
+					  NUM2DBL(maxdelta),
+					  NUM2DBL(area),
+					  NUM2DBL(coolexp),
+					  NUM2DBL(repulserad),
+					  NUM2DBL(cellsize),
+					  use_seed == Qtrue ? 1: 0);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_lgl -> 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_lgl(VALUE self,
+			 VALUE maxit,
+			 VALUE maxdelta,
+			 VALUE area,
+			 VALUE coolexp,
+			 VALUE repulserad,
+			 VALUE cellsize,
+			 VALUE proot){
+
+  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_lgl(graph,res,
+		    NUM2INT(maxit),
+		    NUM2DBL(maxdelta),
+		    NUM2DBL(area),
+		    NUM2DBL(coolexp),
+		    NUM2DBL(repulserad),
+		    NUM2DBL(cellsize),
+		    cIGraph_get_vertex_id(self, proot));
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+