igraph 0.1.1

data/ext/cIGraph_basic_properties.c

@@ -0,0 +1,34 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.are_connected?(from,to) -> true/false
+ *
+ * Returns a boolean specifying whether the two vertices specified are
+ * connected by an edge.
+ *
+ * Example:
+ *
+ *   IGraph.new([1,2,3,4],true)
+ *   graph.are_connected?(1,2) #returns true
+ *
+ */
+
+VALUE cIGraph_are_connected(VALUE self, VALUE from, VALUE to){
+
+  igraph_t *graph;
+  igraph_integer_t from_i;
+  igraph_integer_t to_i;
+  igraph_bool_t res;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  from_i = cIGraph_get_vertex_id(self,from);
+  to_i   = cIGraph_get_vertex_id(self,to);
+
+  igraph_are_connected(graph,from_i,to_i,&res);
+  
+  return res ? Qtrue : Qfalse;
+
+}

data/ext/cIGraph_basic_query.c

@@ -0,0 +1,260 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.vcount() -> Fixnum
+ *
+ * Returns the number of vertices in the IGraph object.
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.vcount # returns 4
+ *
+ */
+
+VALUE cIGraph_vcount(VALUE self){
+  igraph_t *graph;
+
+  Data_Get_Struct(self, igraph_t, graph);
+  return INT2NUM(igraph_vcount(graph));
+}
+
+/* call-seq:
+ *   graph.ecount() -> Fixnum
+ *
+ * Returns the number of edges in the IGraph object.
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.ecount # returns 2
+ *
+ */
+
+VALUE cIGraph_ecount(VALUE self){
+  igraph_t *graph;
+
+  Data_Get_Struct(self, igraph_t, graph);
+  return INT2NUM(igraph_ecount(graph));
+}
+
+/* call-seq:
+ *   graph.edge(eid) -> [from,to]
+ *
+ * Returns an Array comprising the vertices making up the edge represented
+ * by the edge id eid. You can find the id of an edge using IGraph#get_eid.
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.edge(1) # returns [1,2]
+ *
+ */
+
+VALUE cIGraph_edge(VALUE self, VALUE eid){
+    igraph_t *graph;
+    igraph_integer_t from = 0;
+    igraph_integer_t to   = 0;
+    VALUE from_r;
+    VALUE to_r;
+
+    Data_Get_Struct(self, igraph_t, graph);
+
+    igraph_edge(graph,NUM2INT(eid),&from,&to);
+
+    from_r = cIGraph_get_vertex_object(self,from);
+    to_r   = cIGraph_get_vertex_object(self,to);
+
+    return rb_ary_new3(2, from_r, to_r);
+
+}
+
+/* call-seq:
+ *   graph.get_eid(from,to,directed) -> Fixnum
+ *
+ * Returns the edge id of the edge connecting the vertices from and to.
+ * directed is a boolean specifying whether to search for directed edges
+ * in a directed graph.
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.get_eid(1,2,true) # returns 1
+ *
+ */
+VALUE cIGraph_get_eid(VALUE self, VALUE from, VALUE to, VALUE directed){
+    igraph_t *graph;
+    igraph_integer_t eid = 0;
+    int from_i;
+    int to_i;
+    igraph_bool_t directed_b = 0;
+
+    Data_Get_Struct(self, igraph_t, graph);
+
+    from_i = cIGraph_get_vertex_id(self,from);
+    to_i   = cIGraph_get_vertex_id(self,to);
+
+    if(directed)
+      directed_b = 1;
+    
+    igraph_get_eid(graph,&eid,from_i,to_i,directed_b);
+  
+    return INT2NUM(eid);
+
+}
+
+/* call-seq:
+ *   graph.neighbours(vertex,mode) -> Array
+ *
+ * Returns an Array of the neighbouring vertices to vertex. mode defines 
+ * the way adjacent vertices are searched for directed graphs. It can have 
+ * the following values: IGraph::OUT, vertices reachable by an edge from the 
+ * specified vertex are searched, IGraph::IN, vertices from which the 
+ * specified vertex is reachable are searched. IGraph::ALL, both kind of 
+ * vertices are searched. This parameter is ignored for undirected graphs.
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.neighbours(1,IGraph::ALL) # returns [2]
+ *
+ */
+VALUE cIGraph_neighbors(VALUE self, VALUE v, VALUE mode){
+
+  igraph_t *graph;
+  igraph_integer_t pnode;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_t neis;
+  int i;
+  VALUE neighbors = rb_ary_new();
+
+  igraph_vector_init_int(&neis,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  pnode = cIGraph_get_vertex_id(self,v);
+
+  igraph_neighbors(graph,&neis,pnode,pmode);
+
+  for(i=0;i<igraph_vector_size(&neis);i++){
+    rb_ary_push(neighbors,cIGraph_get_vertex_object(self,VECTOR(neis)[i]));
+  }
+
+  igraph_vector_destroy(&neis);
+
+  return neighbors;
+
+}
+
+/* call-seq:
+ *   graph.adjacent(vertex,mode) -> Array
+ *
+ * Returns an Array of the adjacent edge ids to vertex. mode defines 
+ * the way adjacent edges are searched for directed graphs. It can have 
+ * the following values: IGraph::OUT means only outgoing edges, IGraph::IN 
+ * only incoming edges, IGraph::ALL both. This parameter is ignored for 
+ * undirected graphs.
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.adjacent(1,IGraph::ALL) # returns [1]
+ *
+ */
+VALUE cIGraph_adjacent(VALUE self, VALUE v, VALUE mode){
+
+  igraph_t *graph;
+  igraph_integer_t pnode;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_vector_t eids;
+  int i;
+  VALUE eids_r = rb_ary_new();
+
+  igraph_vector_init_int(&eids,0);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  pnode = cIGraph_get_vertex_id(self,v);
+
+  igraph_adjacent(graph,&eids,pnode,pmode);
+
+  for(i=0;i<igraph_vector_size(&eids);i++){
+    rb_ary_push(eids_r,INT2NUM(VECTOR(eids)[i]));
+  }
+
+  igraph_vector_destroy(&eids);
+
+  return eids_r;
+
+}
+
+/* call-seq:
+ *   graph.is_directed?() -> true/false
+ *
+ * Returns a boolean specifying whether the graph is directed or not.
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.is_directed? #returns true
+ *
+ */
+VALUE cIGraph_is_directed(VALUE self){
+  igraph_t *graph;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  return igraph_is_directed(graph) ? Qtrue : Qfalse;
+
+}
+
+/* call-seq:
+ *   graph.degree(vs,mode,loops) -> Array
+ *
+ * Returns an Array of Integers specifying the degree of each of the
+ * vertices specified in the vs Array. 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. 
+ *
+ * Example:
+ *
+ *   g = IGraph.new([1,2,3,4],true)
+ *   g.is_directed? #returns true
+ *
+ */
+VALUE cIGraph_degree(VALUE self, VALUE v, VALUE mode, VALUE loops){
+  igraph_t *graph;
+  igraph_vs_t vids;
+  igraph_vector_t vidv;
+  igraph_neimode_t pmode = NUM2INT(mode);
+  igraph_bool_t loop_mode = loops ? 1 : 0;
+  igraph_vector_t res;
+  int i;
+  VALUE degree_r = 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,v,&vidv);
+  //create vertex selector from the vecotr of ids
+  igraph_vs_vector(&vids,&vidv);
+
+  igraph_degree(graph,&res,vids,pmode,loop_mode);
+
+  for(i=0;i<igraph_vector_size(&res);i++){
+    rb_ary_push(degree_r,INT2NUM(VECTOR(res)[i]));
+  }
+
+  igraph_vector_destroy(&vidv);
+  igraph_vector_destroy(&res);
+  igraph_vs_destroy(&vids);
+
+  return degree_r;
+
+}

data/ext/cIGraph_error_handlers.c

@@ -0,0 +1,13 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+void cIGraph_error_handler(const char *reason, const char *file,
+                             int line, int igraph_errno) {
+  rb_raise(cIGraphError, reason);
+}
+
+void cIGraph_warning_handler(const char *reason, const char *file,
+                             int line, int igraph_errno) {
+  rb_warning(reason);
+}

data/ext/cIGraph_iterators.c

@@ -0,0 +1,135 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+/* call-seq:
+ *   graph.each_vertex{|v| } -> nil
+ *
+ * Iterates through all the vertices in the graph. Also accessible via 
+ * IGraph#each which is used by Enumerable to provide other methods.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.each do |v|
+ *    puts v
+ *  end
+ *  g.find_all{|v| v > 2} #returns [3,4]
+ *
+ */
+
+VALUE cIGraph_each_vertex(VALUE self){
+
+  igraph_t *graph;
+  igraph_vs_t vs;
+  igraph_vit_t vit;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_vs_all(&vs);
+  igraph_vit_create(graph, vs, &vit);
+
+  while(!IGRAPH_VIT_END(vit)) {
+    rb_yield(cIGraph_get_vertex_object(self,IGRAPH_VIT_GET(vit)));
+    IGRAPH_VIT_NEXT(vit);
+  }
+
+  igraph_vit_destroy(&vit);
+  igraph_vs_destroy(&vs);  
+
+  return Qnil;
+
+}
+/* call-seq:
+ *   graph.each_edge(mode){|v,w| } -> nil
+ *
+ * Iterates through all the edges in the graph. mode specifies the order the
+ * edges are returned: 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 are 
+ * the same.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.each_edge(IGraph::EDGORDER_ID) do |v,w|
+ *    puts "#{v} -> #{w}"
+ *  end
+ *
+ */
+VALUE cIGraph_each_edge(VALUE self, VALUE order){
+
+  igraph_t *graph;
+  igraph_es_t es;
+  igraph_eit_t eit;
+  igraph_edgeorder_type_t order_t = NUM2INT(order);
+
+  igraph_integer_t from;
+  igraph_integer_t to;
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_es_all(&es,order_t);
+  igraph_eit_create(graph, es, &eit);
+
+  while(!IGRAPH_EIT_END(eit)) {
+    igraph_edge(graph,IGRAPH_EIT_GET(eit),&from,&to);
+    rb_yield(rb_ary_new3(2,
+			 cIGraph_get_vertex_object(self, from),
+			 cIGraph_get_vertex_object(self, to)));
+    IGRAPH_EIT_NEXT(eit);
+  }
+
+  igraph_eit_destroy(&eit);
+  igraph_es_destroy(&es);    
+
+  return Qnil;
+
+}
+
+/* call-seq:
+ *   graph.each_edge_eid(mode){|id| } -> nil
+ *
+ * Iterates through all the edges in the graph. mode specifies the order the
+ * edges are returned: 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 are 
+ * the same.
+ *
+ * Example:
+ *
+ *  g = IGraph.new([1,2,3,4],true)
+ *  g.each_edge(IGraph::EDGORDER_ID) do |id|
+ *    puts id
+ *  end
+ *
+ */
+VALUE cIGraph_each_edge_eid(VALUE self, VALUE order){
+
+  igraph_t *graph;
+  igraph_es_t es;
+  igraph_eit_t eit;
+  igraph_edgeorder_type_t order_t = NUM2INT(order);
+
+  Data_Get_Struct(self, igraph_t, graph);
+
+  igraph_es_all(&es,order_t);
+  igraph_eit_create(graph, es, &eit);
+
+  while(!IGRAPH_EIT_END(eit)) {
+    rb_yield(INT2NUM(IGRAPH_EIT_GET(eit)));
+    IGRAPH_EIT_NEXT(eit);
+  }
+
+  igraph_eit_destroy(&eit);
+  igraph_es_destroy(&es);    
+
+  return Qnil;
+
+}

data/ext/cIGraph_operators.c

@@ -0,0 +1,9 @@
+#include "igraph.h"
+#include "ruby.h"
+#include "cIGraph.h"
+
+VALUE cIGraph_add_op(VALUE self, VALUE graph){
+
+  return Qnil;
+
+}