igraph 0.3.3 → 0.9.0

data/ext/cIGraph_layout.c

@@ -247,3 +247,46 @@ VALUE cIGraph_layout_lgl(VALUE self,
 
 }
 
+/* call-seq:
+ *   graph.layout_merge_dla(graphs,layouts) -> IGraphMatrix
+ * 
+ * Merge multiple layouts by using a DLA algorithm
+ *
+ * First each layout is covered by a circle. Then the layout of the largest 
+ * graph is placed at the origin. Then the other layouts are placed by the 
+ * DLA algorithm, larger ones first and smaller ones last. 
+ *
+ * graphs: Array of IGraph objects
+ *
+ * layouts: Array of IGraphMatrix layouts
+ */
+VALUE cIGraph_layout_merge_dla(VALUE self, VALUE graphs, VALUE layouts){
+
+  igraph_vector_ptr_t thegraphs;
+  igraph_vector_ptr_t coords;
+  int i;
+  igraph_t *graph;
+  igraph_matrix_t *coord;
+  igraph_matrix_t *res = malloc(sizeof(igraph_matrix_t));
+
+  igraph_vector_ptr_init(&thegraphs,0);
+  igraph_vector_ptr_init(&coords,0);
+  igraph_matrix_init(res,0,0);
+
+  for(i=0;i<RARRAY(graphs)->len;i++){
+    Data_Get_Struct(RARRAY(graphs)->ptr[i], igraph_t, graph);
+    igraph_vector_ptr_push_back(&thegraphs,graph);
+  }
+  for(i=0;i<RARRAY(layouts)->len;i++){
+    Data_Get_Struct(RARRAY(layouts)->ptr[i], igraph_matrix_t, coord);
+    igraph_vector_ptr_push_back(&coords,coord);
+  }
+ 
+  igraph_layout_merge_dla(&thegraphs, &coords, res);
+ 
+  igraph_vector_ptr_destroy(&thegraphs);
+  igraph_vector_ptr_destroy(&coords);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+  
+}

data/ext/cIGraph_layout3d.c

@@ -0,0 +1,119 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.layout_random -> IGraphMatrix
+ * 
+ * Returns a random layout in 3D.
+ */
+VALUE cIGraph_layout_random_3d(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_3d(graph,res);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_sphere -> IGraphMatrix
+ *
+ * Places vertices (more or less) uniformly on a sphere.
+ *
+ * The algorithm was described in the following paper: Distributing many 
+ * points on a sphere by E.B. Saff and A.B.J. Kuijlaars, Mathematical 
+ * Intelligencer 19.1 (1997) 5--11.  
+ */
+VALUE cIGraph_layout_sphere(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_sphere(graph,res);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_fruchterman_reingold_3d(niter,maxdelta,volume,coolexp,repulserad) -> IGraphMatrix
+ *
+ * This is the 3D version of the force based Fruchterman-Reingold layout.
+ *
+ * niter: The number of iterations to do.
+ *
+ * maxdelta: The maximum distance to move a vertex in an iteration.
+ *
+ * volume: The volume parameter of the algorithm.
+ *
+ * coolexp: The cooling exponent of the simulated annealing.
+ *
+ * repulserad: Determines the radius at which vertex-vertex repulsion 
+ * cancels out attraction of adjacent vertices.
+ */
+VALUE cIGraph_layout_fruchterman_reingold_3d(VALUE self,
+					     VALUE niter,
+					     VALUE maxdelta,
+					     VALUE volume,
+					     VALUE coolexp,
+					     VALUE repulserad){
+
+  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_3d(graph,res,
+					NUM2INT(niter),
+					NUM2DBL(maxdelta),
+					NUM2DBL(volume),
+					NUM2DBL(coolexp),
+					NUM2DBL(repulserad),
+					1);
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}
+
+/* call-seq:
+ *   graph.layout_kamada_kawai_3d -> 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_3d(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_3d(graph,res,
+				NUM2INT(niter),
+				NUM2DBL(sigma),
+				NUM2DBL(initemp),
+				NUM2DBL(coolexp),
+				NUM2DBL(kkconst));
+
+  return Data_Wrap_Struct(cIGraphMatrix, 0, cIGraph_matrix_free, res);
+
+}

data/ext/cIGraph_min_cuts.c

@@ -0,0 +1,195 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.maxflow_value(source,target,capacity) -> Max Flow
+ *
+ *  Maximum flow in a network with the push/relabel algorithm
+ *
+ * This function implements the Goldberg-Tarjan algorithm for calculating 
+ * value of the maximum flow in a directed or undirected graph. The algorithm 
+ * was given in Andrew V. Goldberg, Robert E. Tarjan: A New Approach to the 
+ * Maximum-Flow Problem, Journal of the ACM, 35(4), 921-940, 1988.
+ *
+ * Note that the value of the maximum flow is the same as the minimum cut in 
+ * the graph. 
+ *
+ */
+
+VALUE cIGraph_maxflow_value(VALUE self, VALUE source, VALUE target, VALUE capacity){
+
+  igraph_t *graph;
+  igraph_integer_t from_i;
+  igraph_integer_t to_i;
+  igraph_real_t value;
+  
+  int i;
+
+  igraph_vector_t capacity_v;
+
+  igraph_vector_init(&capacity_v, 0);
+  for(i=0;i<RARRAY(capacity)->len;i++){
+    igraph_vector_push_back(&capacity_v,NUM2DBL(RARRAY(capacity)->ptr[i]));
+  }
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  from_i = cIGraph_get_vertex_id(self,source);
+  to_i   = cIGraph_get_vertex_id(self,target);
+
+  igraph_maxflow_value(graph,&value,from_i,to_i,&capacity_v);
+  
+  igraph_vector_destroy(&capacity_v);
+
+  return rb_float_new(value);
+
+}
+
+/* call-seq:
+ *   graph.st_mincut_value(source,target,capacity) -> Max Flow
+ *
+ *  Maximum flow in a network with the push/relabel algorithm
+ *
+ * This function implements the Goldberg-Tarjan algorithm for calculating 
+ * value of the maximum flow in a directed or undirected graph. The algorithm 
+ * was given in Andrew V. Goldberg, Robert E. Tarjan: A New Approach to the 
+ * Maximum-Flow Problem, Journal of the ACM, 35(4), 921-940, 1988.
+ *
+ * Note that the value of the maximum flow is the same as the minimum cut in 
+ * the graph. 
+ *
+ */
+
+VALUE cIGraph_st_mincut_value(VALUE self, VALUE source, VALUE target, VALUE capacity){
+
+  igraph_t *graph;
+  igraph_integer_t from_i;
+  igraph_integer_t to_i;
+  igraph_real_t value;
+  
+  int i;
+
+  igraph_vector_t capacity_v;
+
+  igraph_vector_init(&capacity_v, 0);
+  for(i=0;i<RARRAY(capacity)->len;i++){
+    igraph_vector_push_back(&capacity_v,NUM2DBL(RARRAY(capacity)->ptr[i]));
+  }
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  from_i = cIGraph_get_vertex_id(self,source);
+  to_i   = cIGraph_get_vertex_id(self,target);
+
+  igraph_st_mincut_value(graph,&value,from_i,to_i,&capacity_v);
+  
+  igraph_vector_destroy(&capacity_v);
+
+  return rb_float_new(value);
+
+}
+
+/* call-seq:
+ *   graph.mincut_value(capacity) -> Float
+ *
+ * The minimum edge cut in a graph is the total minimum weight of the edges 
+ * needed to remove from the graph to make the graph not strongly connected.
+ * (If the original graph is not strongly connected then this is zero.) Note
+ * that in undirected graphs strong connectedness is the same as weak 
+ * connectedness.
+ *
+ */
+
+VALUE cIGraph_mincut_value(VALUE self, VALUE capacity){
+
+  igraph_t *graph;
+  igraph_real_t value;
+  
+  int i;
+
+  igraph_vector_t capacity_v;
+
+  igraph_vector_init(&capacity_v, 0);
+  for(i=0;i<RARRAY(capacity)->len;i++){
+    igraph_vector_push_back(&capacity_v,NUM2DBL(RARRAY(capacity)->ptr[i]));
+  }
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_mincut_value(graph,&value,&capacity_v);
+  
+  igraph_vector_destroy(&capacity_v);
+
+  return rb_float_new(value);
+
+}
+
+/* call-seq:
+ *   graph.mincut(capacity) -> Array
+ *
+ * Calculates the minimum cut in a graph. This function calculates the 
+ * minimum cut in a graph. Right now it is implemented only for undirected 
+ * graphs, in which case it uses the Stoer-Wagner algorithm, as described 
+ * in M. Stoer and F. Wagner: A simple min-cut algorithm, Journal of the 
+ * ACM, 44 585-591, 1997.
+ *
+ */
+
+VALUE cIGraph_mincut(VALUE self, VALUE capacity){
+
+  VALUE res_ary;
+
+  VALUE p1_a;
+  VALUE p2_a;
+  VALUE cut_a;
+
+  igraph_t *graph;
+  igraph_real_t value;
+  
+  int i;
+
+  igraph_vector_t p1;
+  igraph_vector_t p2;
+  igraph_vector_t cut;
+
+  igraph_vector_t capacity_v;
+
+  igraph_vector_init(&p1,  0);
+  igraph_vector_init(&p2,  0);
+  igraph_vector_init(&cut, 0);  
+
+  igraph_vector_init(&capacity_v, 0);
+  for(i=0;i<RARRAY(capacity)->len;i++){
+    igraph_vector_push_back(&capacity_v,NUM2DBL(RARRAY(capacity)->ptr[i]));
+  }
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_mincut(graph,&value,&p1,&p2,&cut,&capacity_v);
+
+  p1_a = rb_ary_new();
+  for(i=0;i<igraph_vector_size(&p1);i++){
+    rb_ary_push(p1_a,cIGraph_get_vertex_object(self,VECTOR(p1)[i]));
+  }
+  p2_a = rb_ary_new();
+  for(i=0;i<igraph_vector_size(&p2);i++){
+    rb_ary_push(p2_a,cIGraph_get_vertex_object(self,VECTOR(p2)[i]));
+  }
+  cut_a = rb_ary_new();
+  for(i=0;i<igraph_vector_size(&cut);i++){
+    rb_ary_push(cut_a,INT2NUM(VECTOR(cut)[i]));
+  }
+
+  res_ary = rb_ary_new3(4,rb_float_new(value),p1_a,p2_a,cut_a);
+
+  igraph_vector_destroy(&p1);
+  igraph_vector_destroy(&p2);
+  igraph_vector_destroy(&cut);
+  
+  igraph_vector_destroy(&capacity_v);
+
+  return res_ary;
+
+}
+

data/ext/cIGraph_randomisation.c

@@ -0,0 +1,57 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   g.rewire_edges(prob) -> IGraph
+ *
+ * Rewire the edges of a graph with constant probability This function 
+ * rewires the edges of a graph with a constant probability. More precisely 
+ * each end point of each edge is rewired to an uniformly randomly chosen 
+ * vertex with constant probability prob.
+ *
+ * prob: The rewiring probability a constant between zero and one (inclusive). 
+ */
+VALUE cIGraph_rewire_edges(VALUE self, VALUE prop){
+
+  igraph_t *graph;
+  igraph_t *copy_graph;
+  VALUE new_graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, copy_graph);
+  Data_Get_Struct(self,      igraph_t, graph);
+
+  igraph_copy(copy_graph,graph);
+  igraph_rewire_edges(copy_graph,NUM2DBL(prop));
+
+  return new_graph;
+
+}
+
+/* call-seq:
+ *   g.rewire(n) -> IGraph
+ *
+ * Randomly rewires a graph while preserving the degree distribution.
+ *
+ * This function generates a new graph based on the original one by randomly 
+ * rewiring edges while preserving the original graph's degree distribution.
+ *
+ * n: Number of rewiring trials to perform.
+ */
+VALUE cIGraph_rewire(VALUE self, VALUE n){
+
+  igraph_t *graph;
+  igraph_t *copy_graph;
+  VALUE new_graph;
+
+  new_graph = cIGraph_alloc(cIGraph);
+  Data_Get_Struct(new_graph, igraph_t, copy_graph);
+  Data_Get_Struct(self,      igraph_t, graph);
+
+  igraph_copy(copy_graph,graph);
+  igraph_rewire(copy_graph,NUM2INT(n),0);
+
+  return new_graph;
+
+}

data/ext/cIGraph_utility.c

@@ -8,6 +8,8 @@ igraph_integer_t cIGraph_get_vertex_id(VALUE graph, VALUE v){
   VALUE idx;
   igraph_t *igraph;
 
+  VALUE str;
+
   Data_Get_Struct(graph, igraph_t, igraph);
   v_ary = ((VALUE*)igraph->attr)[0];
 

data/test/tc_add_delete.rb

@@ -56,6 +56,27 @@ class TestGraph < Test::Unit::TestCase
     assert_equal 1, graph.ecount
   end
 
+  def test_delete_large
+    vs = (0..99).to_a
+    h = IGraph.new([],true)
+    vs.each do |id|
+      h.add_vertex(id)
+    end
+    
+    g = h.dup
+
+    delete_ids = (0..99).to_a.sort_by{rand}[0..19]
+    assert_nothing_raised do 
+      delete_ids.each do |id|
+	g.delete_vertex(id)
+      end
+    end
+    delete_ids.each do |id|
+      assert_equal false, g.include?(id)
+    end
+    assert_equal 80, g.vcount
+  end
+
   def test_delete_edge
     graph = IGraph.new(['A','B','C','D'],true)
     assert_equal true, graph.are_connected?('A','B')