igraph 0.3.2 → 0.3.3

data/Manifest.txt

@@ -10,14 +10,20 @@ ext/cIGraph_attribute_handler.c
 ext/cIGraph_basic_properties.c
 ext/cIGraph_basic_query.c
 ext/cIGraph_centrality.c
+ext/cIGraph_cliques.c
 ext/cIGraph_components.c
+ext/cIGraph_dijkstra.c
 ext/cIGraph_direction.c
 ext/cIGraph_error_handlers.c
 ext/cIGraph_file.c
+ext/cIGraph_generators_random.c
+ext/cIGraph_independent_vertex_sets.c
+ext/cIGraph_isomorphism.c
 ext/cIGraph_iterators.c
 ext/cIGraph_kcores.c
 ext/cIGraph_layout.c
 ext/cIGraph_matrix.c
+ext/cIGraph_motif.c
 ext/cIGraph_operators.c
 ext/cIGraph_other_ops.c
 ext/cIGraph_selectors.c
@@ -30,20 +36,27 @@ ext/cIGraph_utility.c
 ext/cIGraph_vertex_neighbourhood.c
 ext/extconf.rb
 test/tc_add_delete.rb
+test/tc_adj_to_distance.rb
 test/tc_attributes.rb
 test/tc_basic_properties.rb
 test/tc_basic_query.rb
 test/tc_centrality.rb
+test/tc_cliques.rb
 test/tc_components.rb
 test/tc_copy.rb
 test/tc_cores.rb
 test/tc_create.rb
+test/tc_dijkstra.rb
 test/tc_directedness.rb
 test/tc_error_handling.rb
 test/tc_file_read_write.rb
+test/tc_generators_random.rb
+test/tc_independent_vertex_sets.rb
+test/tc_isomorphic.rb
 test/tc_iterators.rb
 test/tc_layout.rb
 test/tc_matrix.rb
+test/tc_motif.rb
 test/tc_other_ops.rb
 test/tc_selectors.rb
 test/tc_shortest_paths.rb
@@ -54,3 +67,4 @@ test/tc_topological_sort.rb
 test/tc_transitivity.rb
 test/tc_vertex_neighbourhood.rb
 test/test_all.rb
+test/test_draw.rb

data/Rakefile.rb

@@ -3,7 +3,7 @@ require 'hoe'
 $LOAD_PATH.unshift("./ext")
 
 class IGraph
-  VERSION = "0.0"
+  VERSION = "0.3.3"
 end
 
 begin 

data/ext/cIGraph.c

@@ -184,7 +184,7 @@ void Init_igraph(){
 
   rb_include_module(cIGraph, rb_mEnumerable);
 
-  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.3.2"));
+  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.3.3"));
 
   rb_define_const(cIGraph, "EDGEORDER_ID",   INT2NUM(1));
   rb_define_const(cIGraph, "EDGEORDER_FROM", INT2NUM(2));
@@ -207,6 +207,14 @@ void Init_igraph(){
   rb_define_const(cIGraph, "GET_ADJACENCY_LOWER", INT2NUM(1));
   rb_define_const(cIGraph, "GET_ADJACENCY_BOTH",  INT2NUM(2));  
 
+  rb_define_const(cIGraph, "ERDOS_RENYI_GNP", INT2NUM(0));
+  rb_define_const(cIGraph, "ERDOS_RENYI_GNM", INT2NUM(1));  
+
+  rb_define_singleton_method(cIGraph, "grg_game", cIGraph_grg_game, 3); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph, "barabasi_game", cIGraph_barabasi_game, 4); /* in cIGraph_generators_random.c */ 
+  rb_define_singleton_method(cIGraph, "nonlinear_barabasi_game", cIGraph_nonlinear_barabasi_game, 6); /* in cIGraph_generators_random.c */ 
+rb_define_singleton_method(cIGraph, "erdos_renyi_game", cIGraph_erdos_renyi_game, 5); /* in cIGraph_generators_random.c */ 
+
   rb_define_method(cIGraph, "[]",            cIGraph_get_edge_attr, 2); /* in cIGraph_attribute_handler.c */
   rb_define_method(cIGraph, "[]=",           cIGraph_set_edge_attr, 3); /* in cIGraph_attribute_handler.c */
   rb_define_alias (cIGraph, "get_edge_attr", "[]");
@@ -256,6 +264,9 @@ void Init_igraph(){
   rb_define_method(cIGraph, "diameter",               cIGraph_diameter,               2); /* in cIGraph_shortest_paths.c */
   rb_define_method(cIGraph, "girth",                  cIGraph_girth,                  0); /* in cIGraph_shortest_paths.c */
 
+
+  rb_define_method(cIGraph, "dijkstra_shortest_paths", cIGraph_dijkstra_shortest_paths, 3);
+
   rb_define_method(cIGraph, "neighbourhood_size",   cIGraph_neighborhood_size,   3); /* in cIGraph_vertex_neighbourhood.c */
   rb_define_method(cIGraph, "neighbourhood",        cIGraph_neighborhood,        3); /* in cIGraph_vertex_neighbourhood.c */
   rb_define_method(cIGraph, "neighbourhood_graphs", cIGraph_neighborhood_graphs, 3); /* in cIGraph_vertex_neighbourhood.c */
@@ -296,6 +307,26 @@ void Init_igraph(){
   rb_define_method(cIGraph, "cocitation",    cIGraph_cocitation,    1); /* in cIGraph_other_ops.c */
   rb_define_method(cIGraph, "get_adjacency", cIGraph_get_adjacency, 1); /* in cIGraph_other_ops.c */
   
+  rb_define_method(cIGraph, "cliques",         cIGraph_cliques,         2); /* in cIGraph_cliques.c */
+  rb_define_method(cIGraph, "largest_cliques", cIGraph_largest_cliques, 0); /* in cIGraph_cliques.c */ 
+  rb_define_method(cIGraph, "maximal_cliques", cIGraph_maximal_cliques, 0); /* in cIGraph_cliques.c */ 
+  rb_define_method(cIGraph, "clique_number",   cIGraph_clique_number,   0); /* in cIGraph_cliques.c */ 
+
+  rb_define_method(cIGraph, "independent_vertex_sets", cIGraph_independent_vertex_sets, 2); /* in cIGraph_independent_vertex_sets.c */
+  rb_define_method(cIGraph, "largest_independent_vertex_sets", cIGraph_largest_independent_vertex_sets, 0); /* in cIGraph_independent_vertex_sets.c */
+  rb_define_method(cIGraph, "maximal_independent_vertex_sets", cIGraph_maximal_independent_vertex_sets, 0); /* in cIGraph_independent_vertex_sets.c */
+  rb_define_method(cIGraph, "independence_number", cIGraph_independence_number, 0); /* in cIGraph_independent_vertex_sets.c */
+
+  rb_define_method(cIGraph, "isomorphic",     cIGraph_isomorphic,     1); /* in cIGraph_isomorphism.c */
+  rb_define_method(cIGraph, "isomorphic_vf2", cIGraph_isomorphic_vf2, 1); /* in cIGraph_isomorphism.c */
+  rb_define_method(cIGraph, "isoclass", cIGraph_isoclass, 0); /* in cIGraph_isomorphism.c */
+  rb_define_method(cIGraph, "isoclass_subgraph", cIGraph_isoclass_subgraph, 1); /* in cIGraph_isomorphism.c */
+  rb_define_singleton_method(cIGraph, "isoclass_create", cIGraph_isoclass_create, 3); /* in cIGraph_isomorphism.c */
+
+  rb_define_method(cIGraph, "motifs_randesu",          cIGraph_motifs_randesu,          2); /* in cIGraph_motif.c */ 
+  rb_define_method(cIGraph, "motifs_randesu_no",       cIGraph_motifs_randesu_no,       2); /* in cIGraph_motif.c */ 
+  rb_define_method(cIGraph, "motifs_randesu_estimate", cIGraph_motifs_randesu_estimate, 4); /* in cIGraph_motif.c */ 
+
   rb_define_method(cIGraph, "topological_sorting", cIGraph_topological_sorting, 1); /* in cIGraph_topological_sort.c */
 
   rb_define_singleton_method(cIGraph, "read_graph_edgelist", cIGraph_read_graph_edgelist, 2); /* in cIGraph_file.c */
@@ -305,9 +336,14 @@ void Init_igraph(){
   rb_define_method(cIGraph, "write_graph_graphml", cIGraph_write_graph_graphml,   1);         /* in cIGraph_file.c */  
   rb_define_method(cIGraph, "write_graph_pajek", cIGraph_write_graph_pajek, 1);               /* in cIGraph_file.c */
 
-  rb_define_method(cIGraph, "layout_random",               cIGraph_layout_random,               0); /* in cIGraph_layout.c */
-  rb_define_method(cIGraph, "layout_circle",               cIGraph_layout_circle,               0); /* in cIGraph_layout.c */
-  rb_define_method(cIGraph, "layout_fruchterman_reingold", cIGraph_layout_fruchterman_reingold, 6); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_random",                    cIGraph_layout_random,                        0); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_circle",                    cIGraph_layout_circle,                        0); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_fruchterman_reingold",      cIGraph_layout_fruchterman_reingold,          6); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_kamada_kawai",              cIGraph_layout_kamada_kawai,                  5); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_reingold_tilford",          cIGraph_layout_reingold_tilford,              1); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_reingold_tilford_circular", cIGraph_layout_reingold_tilford_circular, 1); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_grid_fruchterman_reingold", cIGraph_layout_grid_fruchterman_reingold,     7); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph, "layout_lgl",                       cIGraph_layout_lgl,                           7); /* in cIGraph_layout.c */
 
   //Matrix class
   cIGraphMatrix = rb_define_class("IGraphMatrix", rb_cObject);

data/ext/cIGraph.h

@@ -30,6 +30,15 @@ VALUE cIGraph_alloc(VALUE klass);
 VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self);
 VALUE cIGraph_init_copy(VALUE copy, VALUE orig);
 
+//Random graph generators
+VALUE cIGraph_grg_game     (VALUE self, VALUE nodes, 
+			    VALUE radius, VALUE torus);
+VALUE cIGraph_barabasi_game(VALUE self, VALUE nodes, 
+			    VALUE m, VALUE outpref, VALUE directed);
+VALUE cIGraph_nonlinear_barabasi_game(VALUE self, VALUE nodes, VALUE power, 
+				      VALUE m, VALUE outpref, VALUE zeroappeal, VALUE directed);
+VALUE cIGraph_erdos_renyi_game       (VALUE self, VALUE type, VALUE nodes, VALUE mp, VALUE directed, VALUE loops);
+
 //Attribute accessors
 int replace_i(VALUE key, VALUE val, VALUE hash);
 VALUE cIGraph_get_edge_attr(VALUE self, VALUE from, VALUE to);
@@ -81,6 +90,13 @@ VALUE cIGraph_average_path_length   (VALUE self, VALUE directed, VALUE unconn);
 VALUE cIGraph_diameter              (VALUE self, VALUE directed, VALUE unconn);
 VALUE cIGraph_girth                 (VALUE self);
 
+VALUE cIGraph_dijkstra_shortest_paths(VALUE self, VALUE from, VALUE weights, VALUE mode);
+int igraph_dijkstra_shortest_paths(const igraph_t *graph, 
+				   igraph_matrix_t *res, 
+				   const igraph_vs_t from, 
+				   const igraph_vector_t *wghts,
+				   igraph_neimode_t mode);
+
 //Vertex neighbourhood functions
 VALUE cIGraph_neighborhood_size  (VALUE self, VALUE from, VALUE order, VALUE mode);
 VALUE cIGraph_neighborhood       (VALUE self, VALUE from, VALUE order, VALUE mode);
@@ -130,6 +146,31 @@ VALUE cIGraph_bibcoupling  (VALUE self, VALUE vs);
 VALUE cIGraph_cocitation   (VALUE self, VALUE vs);
 VALUE cIGraph_get_adjacency(VALUE self, VALUE mode);
 
+//Cliques
+VALUE cIGraph_cliques(VALUE self, VALUE min, VALUE max);
+VALUE cIGraph_largest_cliques(VALUE self);
+VALUE cIGraph_maximal_cliques(VALUE self);
+VALUE cIGraph_clique_number(VALUE self);
+
+//Independent vertex sets
+VALUE cIGraph_independent_vertex_sets(VALUE self, VALUE min, VALUE max);
+VALUE cIGraph_largest_independent_vertex_sets(VALUE self);
+VALUE cIGraph_maximal_independent_vertex_sets(VALUE self);
+VALUE cIGraph_independence_number(VALUE self);
+
+//Graph isomorphism
+VALUE cIGraph_isomorphic       (VALUE self, VALUE g);
+VALUE cIGraph_isomorphic_vf2   (VALUE self, VALUE g);
+VALUE cIGraph_isoclass         (VALUE self);
+VALUE cIGraph_isoclass_subgraph(VALUE self, VALUE vs);
+VALUE cIGraph_isoclass_create  (VALUE self, VALUE vn, VALUE iso, VALUE dir);
+
+//Motifs
+VALUE cIGraph_motifs_randesu         (VALUE self, VALUE size, VALUE cuts);
+VALUE cIGraph_motifs_randesu_no      (VALUE self, VALUE size, VALUE cuts);
+VALUE cIGraph_motifs_randesu_estimate(VALUE self, VALUE size, VALUE cuts, 
+				      VALUE samplen, VALUE samplev);
+
 //File handling
 VALUE cIGraph_read_graph_edgelist (VALUE self, VALUE file, VALUE mode);
 VALUE cIGraph_write_graph_edgelist(VALUE self, VALUE file);
@@ -139,8 +180,8 @@ VALUE cIGraph_read_graph_pajek    (VALUE self, VALUE file);
 VALUE cIGraph_write_graph_pajek   (VALUE self, VALUE file);
 
 //Layouts
-VALUE cIGraph_layout_random(VALUE self);
-VALUE cIGraph_layout_circle(VALUE self);
+VALUE cIGraph_layout_random              (VALUE self);
+VALUE cIGraph_layout_circle              (VALUE self);
 VALUE cIGraph_layout_fruchterman_reingold(VALUE self,
 					  VALUE niter,
 					  VALUE maxdelta,
@@ -148,6 +189,33 @@ VALUE cIGraph_layout_fruchterman_reingold(VALUE self,
 					  VALUE coolexp,
 					  VALUE repulserad,
 					  VALUE use_seed);
+VALUE cIGraph_layout_kamada_kawai        (VALUE self,
+				          VALUE niter,
+				          VALUE sigma,
+				          VALUE initemp,
+				          VALUE coolexp,
+				          VALUE kkconst);
+VALUE cIGraph_layout_reingold_tilford    (VALUE self,
+				          VALUE root);
+VALUE cIGraph_layout_reingold_tilford_circular(VALUE self,
+					       VALUE root);
+VALUE cIGraph_layout_grid_fruchterman_reingold(VALUE self,
+					       VALUE niter,
+					       VALUE maxdelta,
+					       VALUE area,
+					       VALUE coolexp,
+					       VALUE repulserad,
+					       VALUE cellsize,
+					       VALUE use_seed);
+VALUE cIGraph_layout_lgl(VALUE self,
+			 VALUE maxit,
+			 VALUE maxdelta,
+			 VALUE area,
+			 VALUE coolexp,
+			 VALUE repulserad,
+			 VALUE cellsize,
+			 VALUE proot);
+
 
 //Attributes
 int cIGraph_attribute_init(igraph_t *graph, 

data/ext/cIGraph_attribute_handler.c

@@ -189,6 +189,7 @@ int cIGraph_attribute_add_vertices(igraph_t *graph, long int nv, igraph_vector_p
   VALUE values;
 
   if(attr){
+
     if(igraph_vector_ptr_size(attr) > 0 && ((igraph_i_attribute_record_t*)VECTOR(*attr)[0])->type == IGRAPH_ATTRIBUTE_PY_OBJECT){
 
       values = (VALUE)((igraph_i_attribute_record_t*)VECTOR(*attr)[0])->value;
@@ -234,6 +235,11 @@ int cIGraph_attribute_add_vertices(igraph_t *graph, long int nv, igraph_vector_p
 	rb_ary_push(vertex_array,record);
       }
     }
+  } else {
+    //Default: Add numbered vertices.
+    for(i=0;i<nv;i++){
+      rb_ary_push(vertex_array,INT2NUM(i));
+    }
   }
  
 #ifdef DEBUG

data/ext/cIGraph_cliques.c

@@ -0,0 +1,178 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.cliques(min_size,max_size) -> Array
+ *
+ * Find all or some cliques in a graph
+ *
+ * Cliques are fully connected subgraphs of a graph.
+ *
+ * If you are only interested in the size of the largest clique in the 
+ * graph, use IGraph#clique_number instead. 
+ */
+
+VALUE cIGraph_cliques(VALUE self, VALUE min, VALUE max){
+
+  igraph_t *graph;
+  igraph_vector_ptr_t res;
+  igraph_vector_t *vec;
+  int i;
+  int j;
+  VALUE clique;
+  VALUE object;
+  VALUE cliques = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  igraph_cliques(graph, &res, NUM2INT(min), NUM2INT(max));
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    clique = rb_ary_new();
+    rb_ary_push(cliques,clique);
+    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(clique,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 cliques;
+  
+}
+
+/* call-seq:
+ *   graph.largest_cliques() -> Array
+ *
+ * Finds the largest clique(s) in a graph.
+ *
+ * A clique is largest (quite intuitively) if there is no other clique in 
+ * the graph which contains more vertices.
+ *
+ * Note that this is not neccessarily the same as a maximal clique, ie. 
+ * the largest cliques are always maximal but a maximal clique is not always 
+ * largest. 
+ */
+
+VALUE cIGraph_largest_cliques(VALUE self){
+
+  igraph_t *graph;
+  igraph_vector_ptr_t res;
+  igraph_vector_t *vec;
+  int i;
+  int j;
+  VALUE clique;
+  VALUE object;
+  VALUE cliques = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  igraph_largest_cliques(graph, &res);
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    clique = rb_ary_new();
+    rb_ary_push(cliques,clique);
+    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(clique,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 cliques;
+  
+}
+
+/* call-seq:
+ *   graph.maximal_cliques() -> Array
+ *
+ * Find all maximal cliques of a graph
+ *
+ * A maximal clique is a clique which can't be extended any more by adding a 
+ * new vertex to it. This is actually implemented by looking for a maximal 
+ * independent vertex set in the complementer of the graph.
+ *
+ * If you are only interested in the size of the largest clique in the 
+ * graph, use IGraph#clique_number instead. 
+ */
+
+VALUE cIGraph_maximal_cliques(VALUE self){
+
+  igraph_t *graph;
+  igraph_vector_ptr_t res;
+  igraph_vector_t *vec;
+  int i;
+  int j;
+  VALUE clique;
+  VALUE object;
+  VALUE cliques = rb_ary_new();
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vector_ptr_init(&res,0);
+
+  igraph_maximal_cliques(graph, &res);
+
+  for(i=0; i<igraph_vector_ptr_size(&res); i++){
+    clique = rb_ary_new();
+    rb_ary_push(cliques,clique);
+    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(clique,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 cliques;
+  
+}
+
+/* call-seq:
+ *   graph.clique_number() -> Integer
+ *
+ * Find the clique number of the graph
+ *
+ * The clique number of a graph is the size of the largest clique. 
+ */
+
+VALUE cIGraph_clique_number(VALUE self){
+
+  igraph_t *graph;
+  igraph_integer_t res;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_clique_number(graph, &res);
+
+  return INT2NUM(res);
+  
+}

data/ext/cIGraph_dijkstra.c

@@ -0,0 +1,258 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.dijkstra_shortest_paths(varray,weights,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 given a set of 
+ * edge weights given in the weights Array. 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_dijkstra_shortest_paths(VALUE self, VALUE from, VALUE weights, VALUE mode){
+
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_vector_t wghts;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_matrix_t res;
+  int i;
+  int j;
+  VALUE row;
+  VALUE path_length;
+  VALUE matrix = rb_ary_new();
+  int n_row;
+  int n_col;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  n_row = NUM2INT(rb_funcall(from,rb_intern("length"),0));
+  n_col = igraph_vcount(graph);
+
+  //matrix to hold the results of the calculations
+  igraph_matrix_init(&res,n_row,n_col);
+
+  igraph_vector_init(&wghts,RARRAY(weights)->len);
+
+  for(i=0;i<RARRAY(weights)->len;i++){
+    VECTOR(wghts)[i] = NUM2DBL(RARRAY(weights)->ptr[i]);
+  }
+
+  //Convert an array of vertices to a vector of vertex ids
+  igraph_vector_init_int(&vidv,0);
+  cIGraph_vertex_arr_to_id_vec(self,from,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_dijkstra_shortest_paths(graph,&res,vids,&wghts,pmode);
+
+  for(i=0; i<igraph_matrix_nrow(&res); i++){
+    row = rb_ary_new();
+    rb_ary_push(matrix,row);
+    for(j=0; j<igraph_matrix_ncol(&res); j++){
+      path_length = MATRIX(res,i,j) == n_col ? Qnil : rb_float_new(MATRIX(res,i,j));
+      rb_ary_push(row,path_length);
+    }
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_matrix_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return matrix;
+
+}
+
+/* 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_dijkstra_shortest_paths(VALUE self, VALUE from, VALUE to, VALUE mode){
+
+  igraph_t *graph;
+
+  igraph_integer_t from_vid;
+  igraph_vs_t to_vids;
+  igraph_vector_t to_vidv;
+
+  igraph_neimode_t pmode = NUM2INT(mode);
+
+  igraph_vector_ptr_t res;
+  igraph_vector_t *path_v;
+
+  int i;
+  int j;
+  VALUE path;
+  VALUE matrix = rb_ary_new();
+  int n_paths;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  n_paths = RARRAY(to)->len;
+
+  //vector to hold the results of the calculations
+  igraph_vector_ptr_init(&res,0);
+  for(i=0;i<n_paths;i++){
+    path_v = malloc(sizeof(igraph_vector_t));
+    igraph_vector_init(path_v,0);
+    igraph_vector_ptr_push_back(&res,path_v);
+  }
+
+  //Convert an array of vertices to a vector of vertex ids
+  igraph_vector_init_int(&to_vidv,0);
+  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);
+
+  //The id of the vertex from where we are counting
+  from_vid = cIGraph_get_vertex_id(self, from);
+
+  igraph_get_shortest_paths(graph,&res,from_vid,to_vids,pmode);
+
+  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++){
+      rb_ary_push(path,cIGraph_get_vertex_object(self,VECTOR(*path_v)[j]));
+    }
+  }
+
+  for(i=0;i<n_paths;i++){
+    igraph_vector_destroy(VECTOR(res)[i]);
+    free(VECTOR(res)[i]);
+  }
+
+  igraph_vector_destroy(&to_vidv);
+  igraph_vector_ptr_destroy(&res);
+  igraph_vs_destroy(&to_vids);
+
+  return matrix;
+
+}
+
+int igraph_dijkstra_shortest_paths(const igraph_t *graph, 
+				   igraph_matrix_t *res, 
+				   const igraph_vs_t from, 
+				   const igraph_vector_t *wghts,
+				   igraph_neimode_t mode) {
+
+  long int no_of_nodes=igraph_vcount(graph);
+  long int no_of_from;
+  igraph_real_t *shortest;
+  igraph_real_t min,alt;
+
+  int i, j, uj, included;
+  igraph_integer_t eid, u,v;
+  igraph_vector_t q;
+  igraph_vit_t fromvit;
+  igraph_vector_t neis;
+
+  IGRAPH_CHECK(igraph_vit_create(graph, from, &fromvit));
+  IGRAPH_FINALLY(igraph_vit_destroy, &fromvit);
+
+  no_of_from=IGRAPH_VIT_SIZE(fromvit);
+
+  if (mode != IGRAPH_OUT && mode != IGRAPH_IN && 
+      mode != IGRAPH_ALL) {
+    IGRAPH_ERROR("Invalid mode argument", IGRAPH_EINVMODE);
+  }
+  shortest=calloc(no_of_nodes, sizeof(igraph_real_t));
+  if (shortest==0) {
+    IGRAPH_ERROR("shortest paths failed", IGRAPH_ENOMEM);
+  }
+  IGRAPH_FINALLY(free, shortest);
+
+  IGRAPH_CHECK(igraph_matrix_resize(res, no_of_from, no_of_nodes));
+  igraph_matrix_null(res);
+
+  for (IGRAPH_VIT_RESET(fromvit), i=0; 
+       !IGRAPH_VIT_END(fromvit); 
+       IGRAPH_VIT_NEXT(fromvit), i++) {
+
+     //Start shortest and previous
+    for(j=0;j<no_of_nodes;j++){
+      shortest[j] = INFINITY;
+      //memset(previous,NAN,     no_of_nodes);
+    }
+
+    shortest[(int)IGRAPH_VIT_GET(fromvit)] = 0;
+    igraph_vector_init_seq(&q,0,no_of_nodes-1);
+
+    while(igraph_vector_size(&q) != 0){
+
+      min = INFINITY;
+      u = no_of_nodes;
+      uj = igraph_vector_size(&q);
+      for(j=0;j<igraph_vector_size(&q);j++){
+	v = VECTOR(q)[j];
+	if(shortest[(int)v] < min){
+	  min = shortest[(int)v];
+	  u = v;
+	  uj = j;
+	}
+      }
+      
+      if(min == INFINITY)
+	break;
+
+      igraph_vector_remove(&q,uj);
+
+      igraph_vector_init(&neis,0);
+      igraph_neighbors(graph,&neis,u,mode);
+
+      for(j=0;j<igraph_vector_size(&neis);j++){
+
+	v = VECTOR(neis)[j];
+
+	//v must be in Q
+	included = 0;
+	for(j=0;j<igraph_vector_size(&q);j++){
+	  if(v == VECTOR(q)[j]){
+	    included = 1;
+	    break;
+	  }
+	}
+	
+	if(!included)
+	  continue;
+	
+  	igraph_get_eid(graph,&eid,u,v,1);
+
+	alt = shortest[(int)u] + VECTOR(*wghts)[(int)eid];
+
+	if(alt < shortest[(int)v]){
+	  shortest[(int)v] = alt;
+	}
+      }
+      igraph_vector_destroy(&neis);
+    }
+
+    for(j=0;j<no_of_nodes;j++){
+      MATRIX(*res,i,j) = shortest[j];
+    }
+
+    igraph_vector_destroy(&q);
+
+  }
+
+  /* Clean */
+  free(shortest);
+  igraph_vit_destroy(&fromvit);
+  IGRAPH_FINALLY_CLEAN(2);
+
+  return 0;
+}