igraph 0.3.3 → 0.9.0

data/History.txt

@@ -1,3 +1,8 @@
+= 0.9   2007-11-19
+
+* All igraph functions wrapped
+* Documentation updated with examples
+
 = 0.3.2 2007-09-03
 
 * All 'structural property' functions now complete.

data/Manifest.txt

@@ -11,21 +11,27 @@ ext/cIGraph_basic_properties.c
 ext/cIGraph_basic_query.c
 ext/cIGraph_centrality.c
 ext/cIGraph_cliques.c
+ext/cIGraph_community.c
 ext/cIGraph_components.c
+ext/cIGraph_connectivity.c
 ext/cIGraph_dijkstra.c
 ext/cIGraph_direction.c
 ext/cIGraph_error_handlers.c
 ext/cIGraph_file.c
+ext/cIGraph_generators_deterministic.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_layout3d.c
 ext/cIGraph_matrix.c
+ext/cIGraph_min_cuts.c
 ext/cIGraph_motif.c
 ext/cIGraph_operators.c
 ext/cIGraph_other_ops.c
+ext/cIGraph_randomisation.c
 ext/cIGraph_selectors.c
 ext/cIGraph_shortest_paths.c
 ext/cIGraph_spanning.c
@@ -42,7 +48,9 @@ test/tc_basic_properties.rb
 test/tc_basic_query.rb
 test/tc_centrality.rb
 test/tc_cliques.rb
+test/tc_community.rb
 test/tc_components.rb
+test/tc_connectivity.rb
 test/tc_copy.rb
 test/tc_cores.rb
 test/tc_create.rb
@@ -50,14 +58,18 @@ test/tc_dijkstra.rb
 test/tc_directedness.rb
 test/tc_error_handling.rb
 test/tc_file_read_write.rb
+test/tc_generators_deterministic.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_layout3d.rb
 test/tc_matrix.rb
+test/tc_mincuts.rb
 test/tc_motif.rb
 test/tc_other_ops.rb
+test/tc_randomisation.rb
 test/tc_selectors.rb
 test/tc_shortest_paths.rb
 test/tc_spanning.rb
@@ -67,4 +79,3 @@ test/tc_topological_sort.rb
 test/tc_transitivity.rb
 test/tc_vertex_neighbourhood.rb
 test/test_all.rb
-test/test_draw.rb

data/README.txt

@@ -2,7 +2,7 @@
 
 IGraph is a Ruby extension for interfacing with the C igraph library (http://cneurocvs.rmki.kfki.hu/igraph/). igraph is a library for creating and manipulating graphs with a particular emphasis on network analysis functions.
 
-IGraph is currently in alpha status and although the basic graph creation and manipulation functions are implemented the API should be considered subject to change. The main documentation can be found at http://igraph.rubyforge.org/igraph/.
+IGraph is currently in beta status and the API should be considered stable. The main documentation can be found at http://igraph.rubyforge.org/igraph/ though it is incomplete in places. you can also see the test suite for examples of how to use the various functions.
 
 All bug reports, feature requests and patches are welcome. Please email alexg (at) kuicr.kyoto-u.ac.jp or use the rubyforge forums: http://rubyforge.org/forum/?group_id=3943
 
@@ -16,22 +16,62 @@ IGraph is only available as a gem. The installation requires the location of you
 
 == Documentation
 
-Graph objects are represented in the IGraph class. See the IGraph class documentation for a list of available methods available to build and query graph objects. Any object can be used as a vertex and any edge can be annotated with any kind of object.
+Graph objects are represented in the IGraph class. See the IGraph class documentation for a list of available methods available to build and query graph objects. The graph generators will use simple Integers as the vertices, but you can use any object as a vertex and edges can also be annotated with any kind of object.
 
 Note that many functions require 'mode' constants to tell igraph how you want certain calculations to be made. The constants are listed under the IGraph documentation and should also be made explicit in each methods documentation.
 
-Here is a very quick and simple example:
+Here are three examples which translate the C tutorial programs from the igraph documentation (http://cneurocvs.rmki.kfki.hu/igraph/doc/html/igraph-tutorial.html).
 
- require 'igraph'
+= 1.
 
- #Create an empty directed graph
- graph = IGraph.new([],true)
+  require 'igraph'
 
- #Add two edges (unannotated)
- graph.add_edges([1,2,3,4])
+  g = IGraph::GenerateRandom.erdos_renyi_game(IGraph::ERDOS_RENYI_GNP, 
+					      1000, 5.0/1000,
+					      false, false)
 
- #Count the number of vertices
- graph.vcount # returns 4
+  d = g.diameter(false,true).size-1
+  puts "Diameter of a random graph with average degree 5: #{d}"
+
+= 2.
+
+  require 'igraph'
+
+  graph = IGraph::Generate.lattice([30,30],false,false,true)
+  puts "Average path (lattice): #{graph.average_path_length(false,true)}"
+
+  graph.add_edges(Array.new(20){rand(graph.vcount)})
+  puts "Average path (randomised): #{graph.average_path_length(false,true)}"
+
+= 3.
+
+  require 'igraph'
+
+  edges = [
+    0,  1, 0, 2, 0, 3, 0, 4, 0, 5, 0, 6, 0, 7, 0, 8,
+    0, 10, 0,11, 0,12, 0,13, 0,17, 0,19, 0,21, 0,31,
+    1,  2, 1, 3, 1, 7, 1,13, 1,17, 1,19, 1,21, 1,30,
+    2,  3, 2, 7, 2,27, 2,28, 2,32, 2, 9, 2, 8, 2,13,
+    3,  7, 3,12, 3,13, 4, 6, 4,10, 5, 6, 5,10, 5,16,
+    6, 16, 8,32, 8,32, 8,33, 9,33,13,33,14,32,14,33,
+    15,32,15,33,18,32,18,33,19,33,20,32,20,33,
+    22,32,22,33,23,25,23,27,23,32,23,33,23,29,
+    24,25,24,27,24,31,25,31,26,29,26,33,27,33,
+    28,31,28,33,29,32,29,33,30,32,30,33,31,32,31,33,
+    32,33
+  ]
+
+  g = IGraph.new(edges,false)
+  vs = g.vertices
+
+  max = vs.zip(g.degree(vs,IGraph::ALL,true)).max{|a,b| a[1] <=> b[1]}
+  puts "Maximum degree is      #{sprintf("%10i",max[1])}, vertex #{max[0]}."
+
+  max = vs.zip(g.closeness(vs,IGraph::ALL)).max{|a,b| a[1] <=> b[1]}
+  puts "Maximum closeness is   #{sprintf("%10f",max[1])}, vertex  #{max[0]}."
+
+  max = vs.zip(g.betweenness(vs,IGraph::ALL)).max{|a,b| a[1] <=> b[1]}
+  puts "Maximum betweenness is #{sprintf("%10f",max[1])}, vertex  #{max[0]}."
 
 == License
 

data/Rakefile.rb

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

data/ext/cIGraph.c

@@ -165,12 +165,65 @@ VALUE cIGraph_initialize(int argc, VALUE *argv, VALUE self){
 }
 
 /* Interface to the iGraph[http://cneurocvs.rmki.kfki.hu/igraph/] library
- * for graph and network computation. See IGraph#new for how to create a
- * graph and get started.
+ * for graph and network computation.
+ *
+ * Basic graph operations are defined on the IGraph class itself, but many
+ * other operations are defined in Modules included into IGraph:
+ *
+ * - Deterministic graph generation: IGraph::Generate
+ * - Random graph generation: IGraph::GenerateRandom
+ * - Graph randomisation: IGraph::Randomise
+ * - Shortest paths: IGraph::ShortestPaths
+ * - Vertex neighborhoods: IGraph::Neighborhood
+ * - Graph components: IGraph::Components
+ * - Closeness centrality calculations: IGraph::Closeness
+ * - Spanning tree: IGraph::Spanning
+ * - Transitivity calculations: IGraph::Transitivity
+ * - Spectral properties: IGraph::Spectral
+ * - Coreness: IGraph::KCores
+ * - Other operations: IGraph::OtherOperations
+ * - Clique calculations: IGraph::Cliques
+ * - Independent vertex sets: IGraph::IndependentVertexSets
+ * - Graph isomorphism: IGraph::Isomorphism
+ * - Motifs: IGraph::Motifs
+ * - Sorting: IGraph::Sorting
+ * - File read/write: IGraph::FileRead, IGraph::FileWrite
+ * - Graph layout algorithms: IGraph::Layout
+ * - Minimum cuts: IGraph::MinimumCuts
+ * - Connectivity: IGraph::Connectivity
+ * - Community: IGraph::Community
+ *
+ * Some methods return (or require as a paramter) an IGraphMatrix object. This
+ * class wraps the igraph C matrix type.
  */
 
 void Init_igraph(){
 
+  //Modules
+  VALUE cIGraph_generate;
+  VALUE cIGraph_genrandom;
+  VALUE cIGraph_connectivity;
+  VALUE cIGraph_mincuts;
+  VALUE cIGraph_layout;
+  VALUE cIGraph_clique;
+  VALUE cIGraph_indyver;
+  VALUE cIGraph_isomor;
+  VALUE cIGraph_motifs;
+  VALUE cIGraph_sorting;
+  VALUE cIGraph_filewrite;
+  VALUE cIGraph_fileread;
+  VALUE cIGraph_community;
+  VALUE cIGraph_shortestpaths;
+  VALUE cIGraph_neighborhoodm;
+  VALUE cIGraph_components;
+  VALUE cIGraph_closenessm;
+  VALUE cIGraph_spanning;
+  VALUE cIGraph_transitivitym;
+  VALUE cIGraph_spectral;
+  VALUE cIGraph_kcore;
+  VALUE cIGraph_otherop;
+  VALUE cIGraph_randomise;
+
   igraph_i_set_attribute_table(&cIGraph_attribute_table);
   igraph_set_error_handler(cIGraph_error_handler);
   igraph_set_warning_handler(cIGraph_warning_handler);  
@@ -184,36 +237,40 @@ void Init_igraph(){
 
   rb_include_module(cIGraph, rb_mEnumerable);
 
-  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));
-  rb_define_const(cIGraph, "EDGEORDER_TO",   INT2NUM(3));
-
-  rb_define_const(cIGraph, "OUT",   INT2NUM(1));
-  rb_define_const(cIGraph, "IN",    INT2NUM(2));
-  rb_define_const(cIGraph, "ALL",   INT2NUM(3));
-  rb_define_const(cIGraph, "TOTAL", INT2NUM(4));
-
-  rb_define_const(cIGraph, "WEAK",   INT2NUM(1));
-  rb_define_const(cIGraph, "STRONG", INT2NUM(2));  
-
-  rb_define_const(cIGraph, "ARBITRARY", INT2NUM(0));
-  rb_define_const(cIGraph, "MUTUAL",    INT2NUM(1));
-  rb_define_const(cIGraph, "EACH",      INT2NUM(0));
-  rb_define_const(cIGraph, "COLLAPSE",  INT2NUM(1));
-
-  rb_define_const(cIGraph, "GET_ADJACENCY_UPPER", INT2NUM(0));
-  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 */ 
+  
+  /* Functions for deterministically generating graphs. */
+  cIGraph_generate = rb_define_module_under(cIGraph, "Generate");
+  rb_include_module(cIGraph, cIGraph_generate);       
+
+  rb_define_singleton_method(cIGraph_generate, "adjacency", cIGraph_adjacency, 2); /* in cIGraph_generators_deterministic.c */
+  rb_define_singleton_method(cIGraph_generate, "star", cIGraph_star, 3); /* in cIGraph_generators_deterministic.c */ 
+  rb_define_singleton_method(cIGraph_generate, "lattice", cIGraph_lattice, 4); /* in cIGraph_generators_deterministic.c */ 
+  rb_define_singleton_method(cIGraph_generate, "ring", cIGraph_ring, 4); /* in cIGraph_generators_deterministic.c */ 
+  rb_define_singleton_method(cIGraph_generate, "tree", cIGraph_tree, 3); /* in cIGraph_generators_deterministic.c */ 
+  rb_define_singleton_method(cIGraph_generate, "full", cIGraph_full, 3); /* in cIGraph_generators_deterministic.c */ 
+  rb_define_singleton_method(cIGraph_generate, "atlas", cIGraph_atlas, 1); /* in cIGraph_generators_deterministic.c */ 
+  rb_define_singleton_method(cIGraph_generate, "extended_chordal_ring", cIGraph_extended_chordal_ring, 2); /* in cIGraph_generators_deterministic.c */ 
+
+  /* Functions for randomly generating graphs. */
+  cIGraph_genrandom = rb_define_module_under(cIGraph, "GenerateRandom");
+  rb_include_module(cIGraph, cIGraph_genrandom);       
+
+  rb_define_singleton_method(cIGraph_genrandom, "grg_game", cIGraph_grg_game, 3); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "barabasi_game", cIGraph_barabasi_game, 4); /* in cIGraph_generators_random.c */ 
+  rb_define_singleton_method(cIGraph_genrandom, "nonlinear_barabasi_game", cIGraph_nonlinear_barabasi_game, 6); /* in cIGraph_generators_random.c */ 
+  rb_define_singleton_method(cIGraph_genrandom, "erdos_renyi_game", cIGraph_erdos_renyi_game, 5); /* in cIGraph_generators_random.c */ 
+  rb_define_singleton_method(cIGraph_genrandom, "watts_strogatz_game", cIGraph_watts_strogatz_game, 4); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "degree_sequence_game", cIGraph_degree_sequence_game, 2); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "growing_random_game", cIGraph_growing_random_game, 4); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "callaway_traits_game", cIGraph_callaway_traits_game, 6); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "establishment_game", cIGraph_establishment_game, 6); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "preference_game", cIGraph_preference_game, 6); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "asymmetric_preference_game", cIGraph_asymmetric_preference_game, 5); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "recent_degree_game", cIGraph_recent_degree_game, 7); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "barabasi_aging_game", cIGraph_barabasi_aging_game, 11); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "recent_degree_aging_game", cIGraph_recent_degree_aging_game, 9); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "cited_type_game", cIGraph_cited_type_game, 5); /* in cIGraph_generators_random.c */
+  rb_define_singleton_method(cIGraph_genrandom, "citing_cited_type_game", cIGraph_citing_cited_type_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 */
@@ -257,95 +314,275 @@ rb_define_singleton_method(cIGraph, "erdos_renyi_game", cIGraph_erdos_renyi_game
   rb_define_method(cIGraph, "are_connected",  cIGraph_are_connected,2); /* in cIGraph_basic_properties.c */  
   rb_define_alias (cIGraph, "are_connected?", "are_connected");
 
-  rb_define_method(cIGraph, "shortest_paths",         cIGraph_shortest_paths,         2); /* in cIGraph_shortest_paths.c */
-  rb_define_method(cIGraph, "get_shortest_paths",     cIGraph_get_shortest_paths,     3); /* in cIGraph_shortest_paths.c */
-  rb_define_method(cIGraph, "get_all_shortest_paths", cIGraph_get_all_shortest_paths, 3); /* in cIGraph_shortest_paths.c */  
-  rb_define_method(cIGraph, "average_path_length",    cIGraph_average_path_length,    2); /* in cIGraph_shortest_paths.c */  
-  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, "to_directed",   cIGraph_to_directed,   1); /* in cIGraph_direction.c */
+  rb_define_method(cIGraph, "to_undirected", cIGraph_to_undirected, 1); /* in cIGraph_direction.c */  
 
+  /* These methods randomise a graph by rewiring the edges. */
+  cIGraph_randomise = rb_define_module_under(cIGraph, "Randomise");
+  rb_include_module(cIGraph, cIGraph_randomise);       
+
+  rb_define_method(cIGraph_randomise, "rewire_edges", cIGraph_rewire_edges, 1); /* in cIGraph_randomisation.c */
+  rb_define_method(cIGraph_randomise, "rewire", cIGraph_rewire, 1); /* in cIGraph_randomisation.c */
+
+  /* Functions for calculating the shortest path through a graph */
+  cIGraph_shortestpaths = rb_define_module_under(cIGraph, "ShortestPaths");
+  rb_include_module(cIGraph, cIGraph_shortestpaths);     
+
+  rb_define_method(cIGraph_shortestpaths, "shortest_paths",         cIGraph_shortest_paths,         2); /* in cIGraph_shortest_paths.c */
+  rb_define_method(cIGraph_shortestpaths, "get_shortest_paths",     cIGraph_get_shortest_paths,     3); /* in cIGraph_shortest_paths.c */
+  rb_define_method(cIGraph_shortestpaths, "get_all_shortest_paths", cIGraph_get_all_shortest_paths, 3); /* in cIGraph_shortest_paths.c */  
+  rb_define_method(cIGraph_shortestpaths, "average_path_length",    cIGraph_average_path_length,    2); /* in cIGraph_shortest_paths.c */  
+  rb_define_method(cIGraph_shortestpaths, "diameter",               cIGraph_diameter,               2); /* in cIGraph_shortest_paths.c */
+  rb_define_method(cIGraph_shortestpaths, "girth",                  cIGraph_girth,                  0); /* in cIGraph_shortest_paths.c */
+
+  rb_define_method(cIGraph_shortestpaths, "dijkstra_shortest_paths", cIGraph_dijkstra_shortest_paths, 3); /* in cIGraph_dijkstra.c */
+
+  /* Functions for querying the neighborhood of vertices */
+  cIGraph_neighborhoodm = rb_define_module_under(cIGraph, "Neighborhood");
+  rb_include_module(cIGraph, cIGraph_neighborhoodm);     
+
+  rb_define_method(cIGraph_neighborhoodm, "neighbourhood_size",   cIGraph_neighborhood_size,   3); /* in cIGraph_vertex_neighbourhood.c */
+  rb_define_method(cIGraph_neighborhoodm, "neighbourhood",        cIGraph_neighborhood,        3); /* in cIGraph_vertex_neighbourhood.c */
+  rb_define_method(cIGraph_neighborhoodm, "neighbourhood_graphs", cIGraph_neighborhood_graphs, 3); /* in cIGraph_vertex_neighbourhood.c */
+  rb_define_alias (cIGraph_neighborhoodm, "neighborhood_size", "neighbourhood_size");
+  rb_define_alias (cIGraph_neighborhoodm, "neighborhood", "neighbourhood");
+  rb_define_alias (cIGraph_neighborhoodm, "neighborhood_graphs", "neighbourhood_graphs");
+  rb_define_method(cIGraph_neighborhoodm, "connect_neighborhood", cIGraph_connect_neighborhood, 2); /* in cIGraph_generators_deterministic.c */
+
+  /* Functions for splitting the graph into components */
+  cIGraph_components = rb_define_module_under(cIGraph, "Components");
+  rb_include_module(cIGraph, cIGraph_components);     
+
+  rb_define_method(cIGraph_components, "subcomponent", cIGraph_subcomponent, 2); /* in cIGraph_components.c */
+  rb_define_method(cIGraph_components, "subgraph",     cIGraph_subgraph,     1); /* in cIGraph_components.c */
+  rb_define_method(cIGraph_components, "clusters",     cIGraph_clusters,     1); /* in cIGraph_components.c */
+  rb_define_method(cIGraph_components, "decompose",    cIGraph_decompose,   -1); /* in cIGraph_components.c */
+
+  /* Graph centrality functions */
+  cIGraph_closenessm = rb_define_module_under(cIGraph, "Closeness");
+  rb_include_module(cIGraph, cIGraph_closenessm);     
+
+  rb_define_method(cIGraph_closenessm, "closeness",        cIGraph_closeness,        2); /* in cIGraph_centrality.c */
+  rb_define_method(cIGraph_closenessm, "betweenness",      cIGraph_betweenness,      2); /* in cIGraph_centrality.c */
+  rb_define_method(cIGraph_closenessm, "edge_betweenness", cIGraph_edge_betweenness, 1); /* in cIGraph_centrality.c */
+  rb_define_method(cIGraph_closenessm, "pagerank",         cIGraph_pagerank,         5); /* in cIGraph_centrality.c */  
+  rb_define_method(cIGraph_closenessm, "constraint",       cIGraph_constraint,      -1); /* in cIGraph_centrality.c */  
+  rb_define_method(cIGraph_closenessm, "maxdegree",        cIGraph_maxdegree,        3); /* in cIGraph_centrality.c */    
+
+  /* Minimum spanning tree functions */
+  cIGraph_spanning = rb_define_module_under(cIGraph, "Spanning");
+  rb_include_module(cIGraph, cIGraph_spanning);     
+
+  rb_define_method(cIGraph_spanning, "minimum_spanning_tree_unweighted", cIGraph_minimum_spanning_tree_unweighted, 0); /* in cIGraph_spanning.c */
+  rb_define_method(cIGraph_spanning, "minimum_spanning_tree_prim",       cIGraph_minimum_spanning_tree_prim,       1); /* in cIGraph_spanning.c */
+  
+  /* Graph transitivity functions */
+  cIGraph_transitivitym = rb_define_module_under(cIGraph, "Transitivity");
+  rb_include_module(cIGraph, cIGraph_transitivitym);     
 
-  rb_define_method(cIGraph, "dijkstra_shortest_paths", cIGraph_dijkstra_shortest_paths, 3);
+  rb_define_method(cIGraph_transitivitym, "transitivity",          cIGraph_transitivity,          0); /* in cIGraph_transitivity.c */
+  rb_define_method(cIGraph_transitivitym, "transitivity_local",    cIGraph_transitivity_local,    1); /* in cIGraph_transitivity.c */
+  rb_define_method(cIGraph_transitivitym, "transitivity_avglocal", cIGraph_transitivity_avglocal, 0); /* in cIGraph_transitivity.c */
 
-  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 */
-  rb_define_alias (cIGraph, "neighborhood_size", "neighbourhood_size");
-  rb_define_alias (cIGraph, "neighborhood", "neighbourhood");
-  rb_define_alias (cIGraph, "neighborhood_graphs", "neighbourhood_graphs");
+  /* Functions for the Laplacian matrix. */
+  cIGraph_spectral = rb_define_module_under(cIGraph, "Spectral");
+  rb_include_module(cIGraph, cIGraph_spectral);     
 
-  rb_define_method(cIGraph, "subcomponent", cIGraph_subcomponent, 2); /* in cIGraph_components.c */
-  rb_define_method(cIGraph, "subgraph",     cIGraph_subgraph,     1); /* in cIGraph_components.c */
-  rb_define_method(cIGraph, "clusters",     cIGraph_clusters,     1); /* in cIGraph_components.c */
-  rb_define_method(cIGraph, "decompose",    cIGraph_decompose,   -1); /* in cIGraph_components.c */
+  rb_define_method(cIGraph_spectral, "laplacian", cIGraph_laplacian, 1); /* in cIGraph_spectral.c */
 
-  rb_define_method(cIGraph, "closeness",        cIGraph_closeness,        2); /* in cIGraph_centrality.c */
-  rb_define_method(cIGraph, "betweenness",      cIGraph_betweenness,      2); /* in cIGraph_centrality.c */
-  rb_define_method(cIGraph, "edge_betweenness", cIGraph_edge_betweenness, 1); /* in cIGraph_centrality.c */
-  rb_define_method(cIGraph, "pagerank",         cIGraph_pagerank,         5); /* in cIGraph_centrality.c */  
-  rb_define_method(cIGraph, "constraint",       cIGraph_constraint,      -1); /* in cIGraph_centrality.c */  
-  rb_define_method(cIGraph, "maxdegree",        cIGraph_maxdegree,        3); /* in cIGraph_centrality.c */    
+  /* Functions for finding the coreness of a graph */
+  cIGraph_kcore = rb_define_module_under(cIGraph, "KCores");
+  rb_include_module(cIGraph, cIGraph_kcore);     
 
-  rb_define_method(cIGraph, "minimum_spanning_tree_unweighted", cIGraph_minimum_spanning_tree_unweighted, 0); /* in cIGraph_spanning.c */
-  rb_define_method(cIGraph, "minimum_spanning_tree_prim",       cIGraph_minimum_spanning_tree_prim,       1); /* in cIGraph_spanning.c */
+  rb_define_method(cIGraph_kcore, "coreness", cIGraph_coreness, 1); /* in cIGraph_kcores.c */
 
-  rb_define_method(cIGraph, "transitivity",          cIGraph_transitivity,          0); /* in cIGraph_transitivity.c */
-  rb_define_method(cIGraph, "transitivity_local",    cIGraph_transitivity_local,    1); /* in cIGraph_transitivity.c */
-  rb_define_method(cIGraph, "transitivity_avglocal", cIGraph_transitivity_avglocal, 0); /* in cIGraph_transitivity.c */
+  /* Other general graph operations */
+  cIGraph_otherop = rb_define_module_under(cIGraph, "OtherOperations");
+  rb_include_module(cIGraph, cIGraph_otherop);   
 
-  rb_define_method(cIGraph, "to_directed",   cIGraph_to_directed,   1); /* in cIGraph_direction.c */
-  rb_define_method(cIGraph, "to_undirected", cIGraph_to_undirected, 1); /* in cIGraph_direction.c */  
+  rb_define_method(cIGraph_otherop, "density",       cIGraph_density,       1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph_otherop, "simplify",      cIGraph_simplify,      2); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph_otherop, "reciprocity",   cIGraph_reciprocity,   1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph_otherop, "bibcoupling",   cIGraph_bibcoupling,   1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph_otherop, "cocitation",    cIGraph_cocitation,    1); /* in cIGraph_other_ops.c */
+  rb_define_method(cIGraph_otherop, "get_adjacency", cIGraph_get_adjacency, 1); /* in cIGraph_other_ops.c */
+  
+  /* Clique finding functions */
+  cIGraph_clique = rb_define_module_under(cIGraph, "Cliques");
+  rb_include_module(cIGraph, cIGraph_clique);   
+
+  rb_define_method(cIGraph_clique, "cliques",         cIGraph_cliques,         2); /* in cIGraph_cliques.c */
+  rb_define_method(cIGraph_clique, "largest_cliques", cIGraph_largest_cliques, 0); /* in cIGraph_cliques.c */ 
+  rb_define_method(cIGraph_clique, "maximal_cliques", cIGraph_maximal_cliques, 0); /* in cIGraph_cliques.c */ 
+  rb_define_method(cIGraph_clique, "clique_number",   cIGraph_clique_number,   0); /* in cIGraph_cliques.c */ 
+
+  /* Independent vertex set finding functions */
+  cIGraph_indyver = rb_define_module_under(cIGraph, "IndependentVertexSets");
+  rb_include_module(cIGraph, cIGraph_indyver);  
+
+  rb_define_method(cIGraph_indyver, "independent_vertex_sets", cIGraph_independent_vertex_sets, 2); /* in cIGraph_independent_vertex_sets.c */
+  rb_define_method(cIGraph_indyver, "largest_independent_vertex_sets", cIGraph_largest_independent_vertex_sets, 0); /* in cIGraph_independent_vertex_sets.c */
+  rb_define_method(cIGraph_indyver, "maximal_independent_vertex_sets", cIGraph_maximal_independent_vertex_sets, 0); /* in cIGraph_independent_vertex_sets.c */
+  rb_define_method(cIGraph_indyver, "independence_number", cIGraph_independence_number, 0); /* in cIGraph_independent_vertex_sets.c */
+
+  /* Functions for isomorphism and isoclasses */
+  cIGraph_isomor = rb_define_module_under(cIGraph, "Isomorphism");
+  rb_include_module(cIGraph, cIGraph_isomor);  
+
+  rb_define_method(cIGraph_isomor, "isomorphic",     cIGraph_isomorphic,     1); /* in cIGraph_isomorphism.c */
+  rb_define_method(cIGraph_isomor, "isomorphic_vf2", cIGraph_isomorphic_vf2, 1); /* in cIGraph_isomorphism.c */
+  rb_define_method(cIGraph_isomor, "isoclass", cIGraph_isoclass, 0); /* in cIGraph_isomorphism.c */
+  rb_define_method(cIGraph_isomor, "isoclass_subgraph", cIGraph_isoclass_subgraph, 1); /* in cIGraph_isomorphism.c */
+  rb_define_singleton_method(cIGraph_generate, "isoclass_create", cIGraph_isoclass_create, 3); /* in cIGraph_isomorphism.c */
+
+  /* Motif finding functions */
+  cIGraph_motifs = rb_define_module_under(cIGraph, "Motifs");
+  rb_include_module(cIGraph, cIGraph_motifs);  
+
+  rb_define_method(cIGraph_motifs, "motifs_randesu",          cIGraph_motifs_randesu,          2); /* in cIGraph_motif.c */ 
+  rb_define_method(cIGraph_motifs, "motifs_randesu_no",       cIGraph_motifs_randesu_no,       2); /* in cIGraph_motif.c */ 
+  rb_define_method(cIGraph_motifs, "motifs_randesu_estimate", cIGraph_motifs_randesu_estimate, 4); /* in cIGraph_motif.c */ 
+
+  /* Graph sorting functions. */
+  cIGraph_sorting = rb_define_module_under(cIGraph, "Sorting");
+  rb_include_module(cIGraph, cIGraph_sorting);  
+
+  rb_define_method(cIGraph_sorting, "topological_sorting", cIGraph_topological_sorting, 1); /* in cIGraph_topological_sort.c */
+
+  /* Functions for reading graphs from files */
+  cIGraph_fileread = rb_define_module_under(cIGraph, "FileRead");
+  rb_include_module(cIGraph, cIGraph_fileread);  
+
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_edgelist", cIGraph_read_graph_edgelist, 2); /* in cIGraph_file.c */
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_graphml",  cIGraph_read_graph_graphml, 2);  /* in cIGraph_file.c */  
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_ncol",     cIGraph_read_graph_ncol, 5);     /* in cIGraph_file.c */ 
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_lgl",      cIGraph_read_graph_lgl,  3);     /* in cIGraph_file.c */ 
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_dimacs",   cIGraph_read_graph_dimacs, 2);     /* in cIGraph_file.c */ 
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_graphdb",  cIGraph_read_graph_graphdb, 2);     /* in cIGraph_file.c */ 
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_gml",      cIGraph_read_graph_gml,  1);     /* in cIGraph_file.c */ 
+  rb_define_singleton_method(cIGraph_fileread, "read_graph_pajek",    cIGraph_read_graph_pajek, 2);    /* in cIGraph_file.c */
+  
+  /* Functions for writing graphs to files */
+  cIGraph_filewrite = rb_define_module_under(cIGraph, "FileWrite");
+  rb_include_module(cIGraph, cIGraph_filewrite);
+
+  rb_define_method(cIGraph_filewrite, "write_graph_edgelist", cIGraph_write_graph_edgelist, 1);  /* in cIGraph_file.c */
+  rb_define_method(cIGraph_filewrite, "write_graph_graphml",  cIGraph_write_graph_graphml,   1); /* in cIGraph_file.c */  
+  rb_define_method(cIGraph_filewrite, "write_graph_gml",      cIGraph_write_graph_gml,    1); /* in cIGraph_file.c */  
+  rb_define_method(cIGraph_filewrite, "write_graph_ncol",     cIGraph_write_graph_ncol,   3);    /* in cIGraph_file.c */    
+  rb_define_method(cIGraph_filewrite, "write_graph_lgl",      cIGraph_write_graph_lgl,   4);    /* in cIGraph_file.c */ 
+  rb_define_method(cIGraph_filewrite, "write_graph_dimacs",   cIGraph_write_graph_dimacs, 4);    /* in cIGraph_file.c */ 
+  rb_define_method(cIGraph_filewrite, "write_graph_pajek",    cIGraph_write_graph_pajek, 1);     /* in cIGraph_file.c */
+
+  /* Graph layout functions */
+  cIGraph_layout = rb_define_module_under(cIGraph, "Layout");
+  rb_include_module(cIGraph, cIGraph_layout);
+
+  rb_define_method(cIGraph_layout, "layout_random",                    cIGraph_layout_random,                        0); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph_layout, "layout_circle",                    cIGraph_layout_circle,                        0); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph_layout, "layout_fruchterman_reingold",      cIGraph_layout_fruchterman_reingold,          6); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph_layout, "layout_kamada_kawai",              cIGraph_layout_kamada_kawai,                  5); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph_layout, "layout_reingold_tilford",          cIGraph_layout_reingold_tilford,              1); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph_layout, "layout_reingold_tilford_circular", cIGraph_layout_reingold_tilford_circular, 1); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph_layout, "layout_grid_fruchterman_reingold", cIGraph_layout_grid_fruchterman_reingold,     7); /* in cIGraph_layout.c */
+  rb_define_method(cIGraph_layout, "layout_lgl",                       cIGraph_layout_lgl,                           7); /* in cIGraph_layout.c */
+
+  rb_define_method(cIGraph_layout, "layout_random_3d",               cIGraph_layout_random_3d,               0); /* in cIGraph_layout3d.c */
+  rb_define_method(cIGraph_layout, "layout_sphere",                  cIGraph_layout_sphere,                  0); /* in cIGraph_layout3d.c */
+  rb_define_method(cIGraph_layout, "layout_fruchterman_reingold_3d", cIGraph_layout_fruchterman_reingold_3d, 5); /* in cIGraph_layout3d.c */
+  rb_define_method(cIGraph_layout, "layout_kamada_kawai_3d",         cIGraph_layout_kamada_kawai_3d,         5); /* in cIGraph_layout3d.c */
+
+  rb_define_singleton_method(cIGraph_layout, "layout_merge_dla", cIGraph_layout_merge_dla, 2); /* in cIGraph_layout.c */
+
+  /* Minimum cuts related functions */
+  cIGraph_mincuts = rb_define_module_under(cIGraph, "MinimumCuts");
+  rb_include_module(cIGraph, cIGraph_mincuts);
+
+  rb_define_method(cIGraph_mincuts, "maxflow_value",   cIGraph_maxflow_value,   3); /* in cIGraph_min_cuts.c */ 
+  rb_define_method(cIGraph_mincuts, "st_mincut_value", cIGraph_st_mincut_value, 3); /* in cIGraph_min_cuts.c */  
+  rb_define_method(cIGraph_mincuts, "mincut_value",    cIGraph_mincut_value,    1); /* in cIGraph_min_cuts.c */
+  rb_define_method(cIGraph_mincuts, "mincut",          cIGraph_mincut,          1); /* in cIGraph_min_cuts.c */
+
+  /* Vertex and edge connectivity functions */
+  cIGraph_connectivity = rb_define_module_under(cIGraph, "Connectivity");
+  rb_include_module(cIGraph, cIGraph_connectivity);
+
+  rb_define_method(cIGraph_connectivity, "st_edge_connectivity",   cIGraph_st_edge_connectivity,   2); /* in cIGraph_connectivity.c */   
+  rb_define_method(cIGraph_connectivity, "edge_connectivity",      cIGraph_edge_connectivity,      0); /* in cIGraph_connectivity.c */   
+  rb_define_method(cIGraph_connectivity, "st_vertex_connectivity", cIGraph_st_vertex_connectivity, 3); /* in cIGraph_connectivity.c */   
+  rb_define_method(cIGraph_connectivity, "vertex_connectivity",    cIGraph_vertex_connectivity,    0); /* in cIGraph_connectivity.c */   
+  rb_define_method(cIGraph_connectivity, "edge_disjoint_paths",    cIGraph_edge_disjoint_paths,    2); /* in cIGraph_connectivity.c */ 
+  rb_define_method(cIGraph_connectivity, "vertex_disjoint_paths",  cIGraph_vertex_disjoint_paths,  2); /* in cIGraph_connectivity.c */ 
+  rb_define_method(cIGraph_connectivity, "adhesion",               cIGraph_adhesion,               0); /* in cIGraph_connectivity.c */    
+  rb_define_method(cIGraph_connectivity, "cohesion",               cIGraph_cohesion,               0); /* in cIGraph_connectivity.c */   
+
+  /* Community and modularity related functions */
+  cIGraph_community = rb_define_module_under(cIGraph, "Community");
+  rb_include_module(cIGraph, cIGraph_community);
+  
+  rb_define_method(cIGraph_community, "modularity",   cIGraph_modularity,   1); /* in cIGraph_community.c */
+  rb_define_method(cIGraph_community, "community_to_membership", cIGraph_community_to_membership, 2);  /* in cIGraph_community.c */
+  rb_define_method(cIGraph_community, "community_spinglass", cIGraph_community_spinglass, 8);  /* in cIGraph_community.c */
+  rb_define_method(cIGraph_community, "community_spinglass_single", cIGraph_community_spinglass_single, 5);  /* in cIGraph_community.c */
+  rb_define_method(cIGraph_community, "community_leading_eigenvector", cIGraph_community_leading_eigenvector, 1);  /* in cIGraph_community.c */      
+  rb_define_method(cIGraph_community, "community_leading_eigenvector_naive", cIGraph_community_leading_eigenvector_naive, 1);  /* in cIGraph_community.c */
+  rb_define_method(cIGraph_community, "community_leading_eigenvector_step", cIGraph_community_leading_eigenvector_step, 2);  /* in cIGraph_community.c */       rb_define_method(cIGraph_community, "community_walktrap", cIGraph_community_walktrap, 2);  /* in cIGraph_community.c */      
+  rb_define_method(cIGraph_community, "community_edge_betweenness", cIGraph_community_edge_betweenness, 1);  /* in cIGraph_community.c */  
+  rb_define_method(cIGraph_community, "community_eb_get_merges", cIGraph_community_eb_get_merges, 1);  /* in cIGraph_community.c */  
+  rb_define_method(cIGraph_community, "community_fastgreedy", cIGraph_community_fastgreedy, 0);  /* in cIGraph_community.c */  
+
+  rb_define_const(cIGraph, "VERSION", rb_str_new2("0.9.0"));
+
+  rb_define_const(cIGraph, "EDGEORDER_ID",   INT2NUM(1));
+  rb_define_const(cIGraph, "EDGEORDER_FROM", INT2NUM(2));
+  rb_define_const(cIGraph, "EDGEORDER_TO",   INT2NUM(3));
 
-  rb_define_method(cIGraph, "laplacian", cIGraph_laplacian, 1); /* in cIGraph_spectral.c */
+  rb_define_const(cIGraph, "OUT",   INT2NUM(1));
+  rb_define_const(cIGraph, "IN",    INT2NUM(2));
+  rb_define_const(cIGraph, "ALL",   INT2NUM(3));
+  rb_define_const(cIGraph, "TOTAL", INT2NUM(4));
 
-  rb_define_method(cIGraph, "coreness", cIGraph_coreness, 1); /* in cIGraph_kcores.c */
+  rb_define_const(cIGraph_components, "WEAK",   INT2NUM(1));
+  rb_define_const(cIGraph_components, "STRONG", INT2NUM(2));  
 
-  rb_define_method(cIGraph, "density",       cIGraph_density,       1); /* in cIGraph_other_ops.c */
-  rb_define_method(cIGraph, "simplify",      cIGraph_simplify,      2); /* in cIGraph_other_ops.c */
-  rb_define_method(cIGraph, "reciprocity",   cIGraph_reciprocity,   1); /* in cIGraph_other_ops.c */
-  rb_define_method(cIGraph, "bibcoupling",   cIGraph_bibcoupling,   1); /* in cIGraph_other_ops.c */
-  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 */
-  rb_define_singleton_method(cIGraph, "read_graph_graphml", cIGraph_read_graph_graphml, 2);   /* in cIGraph_file.c */  
-  rb_define_singleton_method(cIGraph, "read_graph_pajek", cIGraph_read_graph_pajek, 2);       /* in cIGraph_file.c */  
-  rb_define_method(cIGraph, "write_graph_edgelist", cIGraph_write_graph_edgelist, 1);         /* in cIGraph_file.c */
-  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_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
+  rb_define_const(cIGraph, "ARBITRARY", INT2NUM(0));
+  rb_define_const(cIGraph, "MUTUAL",    INT2NUM(1));
+  rb_define_const(cIGraph, "EACH",      INT2NUM(0));
+  rb_define_const(cIGraph, "COLLAPSE",  INT2NUM(1));
+
+  rb_define_const(cIGraph_otherop, "GET_ADJACENCY_UPPER", INT2NUM(0));
+  rb_define_const(cIGraph_otherop, "GET_ADJACENCY_LOWER", INT2NUM(1));
+  rb_define_const(cIGraph_otherop, "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_const(cIGraph_generate, "ADJ_DIRECTED",   INT2NUM(0));
+  rb_define_const(cIGraph_generate, "ADJ_UNDIRECTED", INT2NUM(1));
+  rb_define_const(cIGraph_generate, "ADJ_MAX",        INT2NUM(2));
+  rb_define_const(cIGraph_generate, "ADJ_MIN",        INT2NUM(3));
+  rb_define_const(cIGraph_generate, "ADJ_PLUS",       INT2NUM(4));
+  rb_define_const(cIGraph_generate, "ADJ_UPPER",      INT2NUM(5));
+  rb_define_const(cIGraph_generate, "ADJ_LOWER",      INT2NUM(6));
+
+  rb_define_const(cIGraph_generate, "STAR_OUT",        INT2NUM(0));
+  rb_define_const(cIGraph_generate, "STAR_IN",         INT2NUM(1));
+  rb_define_const(cIGraph_generate, "STAR_UNDIRECTED", INT2NUM(2));
+
+  rb_define_const(cIGraph_generate, "TREE_OUT",        INT2NUM(0));
+  rb_define_const(cIGraph_generate, "TREE_IN",         INT2NUM(1));
+  rb_define_const(cIGraph_generate, "TREE_UNDIRECTED", INT2NUM(2));
+
+  rb_define_const(cIGraph_connectivity, "VCONN_NEI_ERROR",    INT2NUM(0));
+  rb_define_const(cIGraph_connectivity, "VCONN_NEI_INFINITY", INT2NUM(1));
+  rb_define_const(cIGraph_connectivity, "VCONN_NEI_IGNORE",   INT2NUM(2));  
+
+  rb_define_const(cIGraph_community, "SPINCOMM_UPDATE_SIMPLE", INT2NUM(0));
+  rb_define_const(cIGraph_community, "SPINCOMM_UPDATE_CONFIG", INT2NUM(1));  
+
+  /* This class wraps the igraph matrix type. It can be created from and 
+   * converted to an Array of Ruby Arrays.
+   */
   cIGraphMatrix = rb_define_class("IGraphMatrix", rb_cObject);
 
   rb_define_alloc_func(cIGraphMatrix, cIGraph_matrix_alloc);