lemongraph 0.0.1

data/ext/lemongraph/graph_item.cc

@@ -0,0 +1,76 @@
+/* Copyright (C) 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of LemonGraph. <https://gitlab.ensta-bretagne.fr/bollenth/lemongraph>
+ *
+ * LemonGraph is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * LemonGraph is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LemonGraph. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+
+#include "lemongraph.hh"
+
+
+VALUE c_GraphItem;
+
+
+/* Document-class: LemonGraph::GraphItem
+ * Base class for nodes, arcs and edges of directed or undirected graphs.
+ */
+
+
+/* @!visibility private
+ */
+VALUE lemongraph_graphitem_initialize(VALUE self, VALUE id, VALUE graph)
+{
+	if (!RB_FIXNUM_P(id))
+		rb_raise(rb_eRuntimeError, "expecting an integer as ID, not a %s", rb_obj_classname(id));
+	rb_iv_set(self, "@id", id);
+	rb_iv_set(self, "@graph", graph);
+	return self;
+}
+
+
+/* Returns _true_ if _other_ has the same class as _self_ and _self_ and _other_ share the same graph and id.
+ * @return [Boolean]
+ */
+VALUE lemongraph_graphitem_is_equal(VALUE self, VALUE other)
+{
+	if (rb_class_of(other) != rb_class_of(self))
+		return Qfalse;
+	return ((rb_iv_get(self, "@id") == rb_iv_get(other, "@id")) && (rb_iv_get(self, "@graph") == rb_iv_get(other, "@graph"))) ? Qtrue : Qfalse;
+}
+
+
+/* @return [Boolean]
+ */
+VALUE lemongraph_graphitem_is_notequal(VALUE self, VALUE other)
+{
+	if (rb_class_of(other) != rb_class_of(self))
+		return Qtrue;
+	return ((rb_iv_get(self, "@id") != rb_iv_get(other, "@id")) || (rb_iv_get(self, "@graph") != rb_iv_get(other, "@graph"))) ? Qtrue : Qfalse;
+}
+
+
+/* Compare _self_ with another graph item.
+ * Returns _nil_ if _other_ and _self_ do not have the same class, else returns `self.id <=> other.id`.
+ * @param other [GraphItem]
+ * @return [Boolean,nil]
+ */
+VALUE lemongraph_graphitem_compare(VALUE self, VALUE other)
+{
+	if (rb_class_of(other) != rb_class_of(self) || rb_iv_get(self, "@graph") != rb_iv_get(other, "@graph"))
+		return Qnil;
+	return rb_funcall(rb_iv_get(self, "@id"), id_comp, 1, rb_iv_get(other, "@id"));
+}
+
+

data/ext/lemongraph/graph_node.cc

@@ -0,0 +1,321 @@
+/* Copyright (C) 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of LemonGraph. <https://gitlab.ensta-bretagne.fr/bollenth/lemongraph>
+ *
+ * LemonGraph is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * LemonGraph is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LemonGraph. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+
+#include "lemongraph.hh"
+
+
+VALUE c_UnNode;
+
+
+/* Document-class: LemonGraph::Graph::Node
+ * Node of a {Graph}.
+ */
+
+
+VALUE lemongraph_make_unnode(const lemon::ListGraph::Node& node, VALUE graph)
+{
+	if (node == lemon::INVALID)
+		return Qnil;
+	VALUE args[2] = {INT2NUM(lemon::ListGraph::id(node)), graph};
+	return rb_class_new_instance(2, args, c_UnNode);
+}
+
+
+/* @!visibility private
+ */
+VALUE lemongraph_unnode_initialize(VALUE self, VALUE id, VALUE graph)
+{
+	if (rb_obj_is_kind_of(graph, c_Graph) != Qtrue) {
+		rb_raise(rb_eRuntimeError, "expecting a %" PRIsVALUE " as graph, not a %s",
+				rb_class_name(c_Graph), rb_obj_classname(graph));
+	}
+	VALUE args[2] = {id, graph};
+	return rb_call_super(2, args);
+}
+
+
+/* Test if the node is valid, i.e. it is a real node of the graph it belongs to.
+ * @return [Boolean]
+ */
+VALUE lemongraph_unnode_is_valid(VALUE self)
+{
+	return lemongraph_graph_rb2ref(rb_iv_get(self, "@graph")).valid(lemongraph_rbunnode2unnode(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Erases the node from the graph it belongs to.
+ * @return [self]
+ */
+VALUE lemongraph_unnode_erase(VALUE self)
+{
+	lemongraph_graph_rb2ref(rb_iv_get(self, "@graph")).erase(lemongraph_rbunnode2unnode(self));
+	return self;
+}
+
+
+/* Contracts _self_ into the given node.
+ * _self_ is removed, but instead of deleting its incident edges, they are joined to node _other_.
+ * If _remove_new_loops_ is _true_ (this is the default), then the newly created loops are removed.
+ * @return [Node] _other_ is returned, _self_ is erased
+ * @overload contract_in(other, remove_new_loops = true)
+ *  @param other [Node] the node in which to contract _self_
+ *  @param remove_new_loops [Boolean] whether or not to remove newly created loops
+ */
+VALUE lemongraph_unnode_contract(int argc, VALUE *argv, VALUE self)
+{
+	if (argc < 1 || argc > 2)
+		rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 1..2)", argc);
+	bool remove_new_loops = true;
+	VALUE other = argv[0];
+	if (argc == 2)
+		remove_new_loops = (argv[1] != Qnil && argv[1] != Qfalse);
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph &g = lemongraph_graph_rb2ref(rbg);
+	lemongraph_graph_raise_if_not_valid_node(g, rbg, self);
+	lemongraph_graph_raise_if_not_valid_node(g, rbg, other);
+	g.contract(lemongraph_rbunnode2unnode(other), lemongraph_rbunnode2unnode(self), remove_new_loops);
+	return other;
+}
+
+
+/* Number of edges incident to the node.
+ * @return [Integer]
+ */
+VALUE lemongraph_unnode_nb_edges(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	return INT2NUM(lemon::countIncEdges(g, n));
+}
+
+
+/* Returns an array containing all the edges incident to the node.
+ * @return [Array<Edge>]
+ */
+VALUE lemongraph_unnode_edges(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	VALUE ar = rb_ary_new_capa(lemon::countIncEdges(g, n));
+	for (lemon::ListGraph::IncEdgeIt e(g, n); e != lemon::INVALID; ++e)
+		rb_ary_push(ar, lemongraph_make_unedge(e, rbg));
+	return ar;
+}
+
+
+static VALUE lemongraph_unnode_edgeenum_nbedges(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_unnode_nb_edges(obj);
+}
+
+
+/* Calls the block, if given, once for each edges incident to the node.
+ * The edges are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_edge
+ *  @yieldparam edge [Edge]
+ *  @return [self]
+ * @overload each_edge
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_unnode_each_edge(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_unnode_edgeenum_nbedges);
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	for (lemon::ListGraph::IncEdgeIt e(g, n); e != lemon::INVALID; ++e)
+		rb_yield(lemongraph_make_unedge(e, rbg));
+	return self;
+}
+
+
+/* Number of incoming arcs to the node.
+ * @return [Integer]
+ */
+VALUE lemongraph_unnode_nb_inarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	return INT2NUM(lemon::countInArcs(g, n));
+}
+
+
+/* Returns an array containing all the incoming arcs to the node.
+ * @return [Array<Arc>]
+ */
+VALUE lemongraph_unnode_inarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	VALUE ar = rb_ary_new_capa(lemon::countInArcs(g, n));
+	for (lemon::ListGraph::InArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_ary_push(ar, lemongraph_make_unarc(a, rbg));
+	return ar;
+}
+
+
+static VALUE lemongraph_unnode_inarcenum_nbinarcs(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_unnode_nb_inarcs(obj);
+}
+
+
+/* Calls the block, if given, once for each incoming {Arc} of the node.
+ * The arcs are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_inarc
+ *  @yieldparam arc [Arc]
+ *  @return [self]
+ * @overload each_inarc
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_unnode_each_inarc(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_unnode_inarcenum_nbinarcs);
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	for (lemon::ListGraph::InArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_yield(lemongraph_make_unarc(a, rbg));
+	return self;
+}
+
+
+/* Number of outgoing arcs from the node.
+ * @return [Integer]
+ */
+VALUE lemongraph_unnode_nb_outarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	return INT2NUM(lemon::countOutArcs(g, n));
+}
+
+
+/* Returns an array containing all the outgoing arcs from the node.
+ * @return [Array<Arc>]
+ */
+VALUE lemongraph_unnode_outarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	VALUE ar = rb_ary_new_capa(lemon::countOutArcs(g, n));
+	for (lemon::ListGraph::OutArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_ary_push(ar, lemongraph_make_unarc(a, rbg));
+	return ar;
+}
+
+
+static VALUE lemongraph_unnode_outarcenum_nboutarcs(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_unnode_nb_outarcs(obj);
+}
+
+
+/* Calls the block, if given, once for each outgoing {Arc} from the node.
+ * The arcs are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_outarc
+ *  @yieldparam arc [Arc]
+ *  @return [self]
+ * @overload each_outarc
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_unnode_each_outarc(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_unnode_outarcenum_nboutarcs);
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	lemon::ListGraph::Node n = lemongraph_rbunnode2unnode(self);
+	for (lemon::ListGraph::OutArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_yield(lemongraph_make_unarc(a, rbg));
+	return self;
+}
+
+
+/* Creates an {Edge} from _self_ to node _v_.
+ * @param v [Node] node to form an edge with
+ * @return [Edge]
+ */
+VALUE lemongraph_unnode_edge_to(VALUE self, VALUE v)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	return lemongraph_graph_add_edge(rbg, self, v);
+}
+
+
+/* Creates an {Edge} from node _u_ to _self_.
+ * @param u [Node] node to form an edge with
+ * @return [Edge]
+ */
+VALUE lemongraph_unnode_edge_from(VALUE self, VALUE u)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	return lemongraph_graph_add_edge(rbg, u, self);
+}
+
+
+/* Returns the node opposite to _self_ on _edge_.
+ * Returns _nil_ if _edge_ is not incident to _self_.
+ * @param edge [Edge, Arc]
+ * @return [Node]
+ */
+VALUE lemongraph_unnode_opposite(VALUE self, VALUE edge)
+{
+	VALUE r;
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(rbg);
+	VALUE klass = rb_class_of(edge);
+	if (klass == c_UnEdge) {
+		if (rb_iv_get(edge, "@graph") != rbg)
+			rb_raise(rb_eRuntimeError, "node and edge are not from the same graph");
+		r = lemongraph_make_unnode(g.oppositeNode(lemongraph_rbunnode2unnode(self), lemongraph_rbunedge2unedge(edge)), rbg);
+	}
+	else if (klass == c_UnArc) {
+		if (rb_iv_get(edge, "@graph") != rbg)
+			rb_raise(rb_eRuntimeError, "node and arc are not from the same graph");
+		r = lemongraph_make_unnode(g.oppositeNode(lemongraph_rbunnode2unnode(self), lemongraph_rbunarc2unarc(edge)), rbg);
+	}
+	else {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " or a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_UnEdge), rb_class_name(c_UnArc), rb_obj_classname(edge));
+	}
+	return r;
+}
+
+

data/ext/lemongraph/lemongraph.cc

@@ -0,0 +1,260 @@
+/* Copyright (C) 2022 Théotime Bollengier <theotime.bollengier@ensta-bretagne.fr>
+ *
+ * This file is part of LemonGraph. <https://gitlab.ensta-bretagne.fr/bollenth/lemongraph>
+ *
+ * LemonGraph is free software: you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published
+ * by the Free Software Foundation, either version 3 of the License,
+ * or (at your option) any later version.
+ *
+ * LemonGraph is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with LemonGraph. If not, see <https://www.gnu.org/licenses/>. 
+ */
+
+/* TODO:
+ * nodemap
+ * arcmap
+ * edgemap
+ * to_graphviz edgemap arcmap
+ */
+
+#include <ruby.h>
+#include "lemongraph.hh"
+
+
+VALUE m_LemonGraph;
+
+ID id_comp;
+ID id_eqeq;
+
+
+/* Document-module: LemonGraph
+ * Top-level namespace.
+ */
+
+
+extern "C" LEMONGRAPH_PUBLIC void Init_lemongraph()
+{
+	id_comp = rb_intern("<=>");
+	id_eqeq = rb_intern("==");
+
+	m_LemonGraph = rb_define_module("LemonGraph");
+
+	c_GraphItem = rb_define_class_under(m_LemonGraph, "GraphItem", rb_cObject);
+	rb_include_module(c_GraphItem, rb_mComparable);
+	rb_define_method(c_GraphItem, "initialize", lemongraph_graphitem_initialize, 2); // in ext/lemongraph/graph_item.cc
+	rb_undef_method(rb_class_of(c_GraphItem), "new");
+	rb_define_attr(c_GraphItem,   "id",    1, 0); // @return [Integer] the graph item's id
+	rb_define_attr(c_GraphItem,   "graph", 1, 0); // @return [Digraph,Graph] the graph the item belongs to
+	rb_define_method(c_GraphItem, "==",         lemongraph_graphitem_is_equal,    1); // in ext/lemongraph/graph_item.cc
+	rb_define_method(c_GraphItem, "!=",         lemongraph_graphitem_is_notequal, 1); // in ext/lemongraph/graph_item.cc
+	rb_define_method(c_GraphItem, "<=>",        lemongraph_graphitem_compare,     1); // in ext/lemongraph/graph_item.cc
+
+	/**************************** Digraph *************************************/
+
+	c_Digraph = rb_define_class_under(m_LemonGraph, "Digraph", rb_cObject);
+	rb_define_alloc_func(c_Digraph, lemongraph_digraph_alloc);
+	rb_undef_method(rb_class_of(c_Digraph),  "allocate");
+	rb_define_method(c_Digraph, "initialize_copy", lemongraph_digraph_initialize_copy, 1); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "add_node",  lemongraph_digraph_add_node,      0); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "add_arc",   lemongraph_digraph_add_arc,       2); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "valid?",    lemongraph_digraph_item_is_valid, 1); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "erase",     lemongraph_digraph_erase_nodearc, 1); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "clear",     lemongraph_digraph_clear,         0); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "nb_nodes",  lemongraph_digraph_nb_nodes,      0); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "nodes",     lemongraph_digraph_nodes,         0); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "each_node", lemongraph_digraph_each_node,     0); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "nb_arcs",   lemongraph_digraph_nb_arcs,       0); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "arcs",      lemongraph_digraph_arcs,          0); // in ext/lemongraph/digraph.cc
+	rb_define_method(c_Digraph, "each_arc",  lemongraph_digraph_each_arc,      0); // in ext/lemongraph/digraph.cc
+
+	c_DiNode = rb_define_class_under(c_Digraph, "Node", c_GraphItem);
+	rb_define_method(c_DiNode, "initialize",  lemongraph_dinode_initialize,  2); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "valid?",      lemongraph_dinode_is_valid,    0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "erase",       lemongraph_dinode_erase,       0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "arc_to",      lemongraph_dinode_arc_to,      1); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "arc_from",    lemongraph_dinode_arc_from,    1); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "split",       lemongraph_dinode_split,      -1); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "contract_in", lemongraph_dinode_contract,   -1); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "nb_inarcs",   lemongraph_dinode_nb_inarcs,   0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "inarcs",      lemongraph_dinode_inarcs,      0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "each_inarc",  lemongraph_dinode_each_inarc,  0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "nb_outarcs",  lemongraph_dinode_nb_outarcs,  0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "outarcs",     lemongraph_dinode_outarcs,     0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "each_outarc", lemongraph_dinode_each_outarc, 0); // in ext/lemongraph/digraph_node.cc
+	rb_define_method(c_DiNode, "opposite",    lemongraph_dinode_opposite,    1); // in ext/lemongraph/digraph_node.cc
+
+	c_DiArc = rb_define_class_under(c_Digraph, "Arc", c_GraphItem);
+	rb_define_method(c_DiArc, "initialize", lemongraph_diarc_initialize,    2); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "valid?",     lemongraph_diarc_is_valid,      0); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "erase",      lemongraph_diarc_erase,         0); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "source",     lemongraph_diarc_source,        0); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "source=",    lemongraph_diarc_change_source, 1); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "target",     lemongraph_diarc_target,        0); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "target=",    lemongraph_diarc_change_target, 1); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "reverse!",   lemongraph_diarc_reverse,       0); // in ext/lemongraph/digraph_arc.cc
+	rb_define_method(c_DiArc, "split",      lemongraph_diarc_split,         0); // in ext/lemongraph/digraph_arc.cc
+
+	/****************************** Graph *************************************/
+
+	c_Graph = rb_define_class_under(m_LemonGraph, "Graph", rb_cObject);
+	rb_define_alloc_func(c_Graph, lemongraph_graph_alloc);
+	rb_undef_method(rb_class_of(c_Graph),  "allocate");
+	rb_define_method(c_Graph, "initialize_copy", lemongraph_graph_initialize_copy, 1); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "add_node",  lemongraph_graph_add_node,      0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "add_edge",  lemongraph_graph_add_edge,      2); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "valid?",    lemongraph_graph_item_is_valid, 1); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "erase",     lemongraph_graph_erase_item,    1); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "clear",     lemongraph_graph_clear,         0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "nb_nodes",  lemongraph_graph_nb_nodes,      0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "nodes",     lemongraph_graph_nodes,         0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "each_node", lemongraph_graph_each_node,     0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "nb_edges",  lemongraph_graph_nb_edges,      0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "edges",     lemongraph_graph_edges,         0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "each_edge", lemongraph_graph_each_edge,     0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "nb_arcs",   lemongraph_graph_nb_arcs,       0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "arcs",      lemongraph_graph_arcs,          0); // in ext/lemongraph/graph.cc
+	rb_define_method(c_Graph, "each_arc",  lemongraph_graph_each_arc,      0); // in ext/lemongraph/graph.cc
+
+	c_UnNode = rb_define_class_under(c_Graph, "Node", c_GraphItem);
+	rb_define_method(c_UnNode, "initialize",  lemongraph_unnode_initialize,  2); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "valid?",      lemongraph_unnode_is_valid,    0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "erase",       lemongraph_unnode_erase,       0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "edge_to",     lemongraph_unnode_edge_to,     1); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "edge_from",   lemongraph_unnode_edge_from,   1); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "contract_in", lemongraph_unnode_contract,   -1); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "nb_edges",    lemongraph_unnode_nb_edges,    0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "edges",       lemongraph_unnode_edges,       0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "each_edge",   lemongraph_unnode_each_edge,   0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "nb_inarcs",   lemongraph_unnode_nb_inarcs,   0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "inarcs",      lemongraph_unnode_inarcs,      0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "each_inarc",  lemongraph_unnode_each_inarc,  0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "nb_outarcs",  lemongraph_unnode_nb_outarcs,  0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "outarcs",     lemongraph_unnode_outarcs,     0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "each_outarc", lemongraph_unnode_each_outarc, 0); // in ext/lemongraph/graph_node.cc
+	rb_define_method(c_UnNode, "opposite",    lemongraph_unnode_opposite,    1); // in ext/lemongraph/graph_node.cc
+
+	c_UnEdge = rb_define_class_under(c_Graph, "Edge", c_GraphItem);
+	rb_define_method(c_UnEdge, "initialize", lemongraph_unedge_initialize, 2); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "valid?",     lemongraph_unedge_is_valid,   0); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "erase",      lemongraph_unedge_erase,      0); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "u",          lemongraph_unedge_u,          0); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "u=",         lemongraph_unedge_change_u,   1); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "v",          lemongraph_unedge_v,          0); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "v=",         lemongraph_unedge_change_v,   1); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "arc1",       lemongraph_unedge_arc1,       0); // in ext/lemongraph/graph_edge.cc
+	rb_define_method(c_UnEdge, "arc2",       lemongraph_unedge_arc2,       0); // in ext/lemongraph/graph_edge.cc
+
+	c_UnArc = rb_define_class_under(c_Graph, "Arc", c_GraphItem);
+	rb_define_method(c_UnArc, "initialize", lemongraph_unarc_initialize, 2); // in ext/lemongraph/graph_arc.cc
+	rb_define_method(c_UnArc, "valid?",     lemongraph_unarc_is_valid,   0); // in ext/lemongraph/graph_arc.cc
+	rb_define_method(c_UnArc, "source",     lemongraph_unarc_source,     0); // in ext/lemongraph/graph_arc.cc
+	rb_define_method(c_UnArc, "target",     lemongraph_unarc_target,     0); // in ext/lemongraph/graph_arc.cc
+	rb_define_method(c_UnArc, "opposite",   lemongraph_unarc_opposite,   0); // in ext/lemongraph/graph_arc.cc
+
+	/****************************** NodeMap ***********************************/
+
+	c_NodeMap = rb_define_class_under(m_LemonGraph, "NodeMap", rb_cObject);
+	rb_include_module(c_NodeMap, rb_mEnumerable);
+	rb_define_alloc_func(c_NodeMap, lemongraph_nodemap_alloc);
+	rb_undef_method(rb_class_of(c_NodeMap), "allocate");
+	rb_define_method(c_NodeMap, "initialize",      lemongraph_nodemap_initialize,     -1); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "initialize_copy", lemongraph_nodemap_initialize_copy, 1); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "graph",           lemongraph_nodemap_graph,           0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "default",         lemongraph_nodemap_get_dflt_val,    0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "default=",        lemongraph_nodemap_set_dflt_val,    1); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "default_proc",    lemongraph_nodemap_get_dflt_proc,   0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "default_proc=",   lemongraph_nodemap_set_dflt_proc,   1); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "==",              lemongraph_nodemap_is_equal,        1); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "hash",            lemongraph_nodemap_hash,            0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "length",          lemongraph_nodemap_length,          0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "empty?",          lemongraph_nodemap_is_empty,        0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "[]",              lemongraph_nodemap_get,             1); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "[]=",             lemongraph_nodemap_set,             2); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "delete",          lemongraph_nodemap_delete,          1); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "delete_if",       lemongraph_nodemap_delete_if,       0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "has_node?",       lemongraph_nodemap_has_node,        1); // in ext/lemongraph/node_map.cc
+	rb_define_alias(c_NodeMap,  "node?",           "has_node?");
+	rb_define_method(c_NodeMap, "has_value?",      lemongraph_nodemap_has_value,       1); // in ext/lemongraph/node_map.cc
+	rb_define_alias(c_NodeMap,  "value?",          "has_value?");
+	rb_define_method(c_NodeMap, "nodes",           lemongraph_nodemap_nodes,           0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "values",          lemongraph_nodemap_values,          0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "each_node",       lemongraph_nodemap_each_node,       0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "each_value",      lemongraph_nodemap_each_value,      0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "each_pair",       lemongraph_nodemap_each_pair,       0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "each",            lemongraph_nodemap_each_pair,       0); // in ext/lemongraph/node_map.cc
+	rb_define_method(c_NodeMap, "clear",           lemongraph_nodemap_clear,           0); // in ext/lemongraph/node_map.cc
+
+	/****************************** ArcMap ************************************/
+
+	c_ArcMap = rb_define_class_under(m_LemonGraph, "ArcMap", rb_cObject);
+	rb_include_module(c_ArcMap, rb_mEnumerable);
+	rb_define_alloc_func(c_ArcMap, lemongraph_arcmap_alloc);
+	rb_undef_method(rb_class_of(c_ArcMap), "allocate");
+	rb_define_method(c_ArcMap, "initialize",      lemongraph_arcmap_initialize,     -1); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "initialize_copy", lemongraph_arcmap_initialize_copy, 1); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "graph",           lemongraph_arcmap_graph,           0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "default",         lemongraph_arcmap_get_dflt_val,    0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "default=",        lemongraph_arcmap_set_dflt_val,    1); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "default_proc",    lemongraph_arcmap_get_dflt_proc,   0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "default_proc=",   lemongraph_arcmap_set_dflt_proc,   1); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "==",              lemongraph_arcmap_is_equal,        1); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "hash",            lemongraph_arcmap_hash,            0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "length",          lemongraph_arcmap_length,          0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "empty?",          lemongraph_arcmap_is_empty,        0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "[]",              lemongraph_arcmap_get,             1); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "[]=",             lemongraph_arcmap_set,             2); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "delete",          lemongraph_arcmap_delete,          1); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "delete_if",       lemongraph_arcmap_delete_if,       0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "has_arc?",        lemongraph_arcmap_has_arc,         1); // in ext/lemongraph/arc_map.cc
+	rb_define_alias(c_ArcMap,  "arc?",            "has_arc?");
+	rb_define_method(c_ArcMap, "has_value?",      lemongraph_arcmap_has_value,       1); // in ext/lemongraph/arc_map.cc
+	rb_define_alias(c_ArcMap,  "value?",          "has_value?");
+	rb_define_method(c_ArcMap, "arcs",            lemongraph_arcmap_arcs,            0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "values",          lemongraph_arcmap_values,          0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "each_arc",        lemongraph_arcmap_each_arc,        0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "each_value",      lemongraph_arcmap_each_value,      0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "each_pair",       lemongraph_arcmap_each_pair,       0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "each",            lemongraph_arcmap_each_pair,       0); // in ext/lemongraph/arc_map.cc
+	rb_define_method(c_ArcMap, "clear",           lemongraph_arcmap_clear,           0); // in ext/lemongraph/arc_map.cc
+
+	/****************************** EdgeMap ***********************************/
+
+	c_EdgeMap = rb_define_class_under(m_LemonGraph, "EdgeMap", rb_cObject);
+	rb_include_module(c_EdgeMap, rb_mEnumerable);
+	rb_define_alloc_func(c_EdgeMap, lemongraph_arcmap_alloc);
+	rb_undef_method(rb_class_of(c_EdgeMap), "allocate");
+	rb_define_method(c_EdgeMap, "initialize",      lemongraph_edgemap_initialize,     -1); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "initialize_copy", lemongraph_edgemap_initialize_copy, 1); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "graph",           lemongraph_edgemap_graph,           0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "default",         lemongraph_edgemap_get_dflt_val,    0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "default=",        lemongraph_edgemap_set_dflt_val,    1); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "default_proc",    lemongraph_edgemap_get_dflt_proc,   0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "default_proc=",   lemongraph_edgemap_set_dflt_proc,   1); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "==",              lemongraph_edgemap_is_equal,        1); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "hash",            lemongraph_edgemap_hash,            0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "length",          lemongraph_edgemap_length,          0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "empty?",          lemongraph_edgemap_is_empty,        0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "[]",              lemongraph_edgemap_get,             1); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "[]=",             lemongraph_edgemap_set,             2); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "delete",          lemongraph_edgemap_delete,          1); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "delete_if",       lemongraph_edgemap_delete_if,       0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "has_edge?",       lemongraph_edgemap_has_edge,        1); // in ext/lemongraph/edge_map.cc
+	rb_define_alias(c_EdgeMap,  "edge?",           "has_edge?");
+	rb_define_method(c_EdgeMap, "has_value?",      lemongraph_edgemap_has_value,       1); // in ext/lemongraph/edge_map.cc
+	rb_define_alias(c_EdgeMap,  "value?",          "has_value?");
+	rb_define_method(c_EdgeMap, "edges",           lemongraph_edgemap_edges,           0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "values",          lemongraph_edgemap_values,          0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "each_edge",       lemongraph_edgemap_each_edge,       0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "each_value",      lemongraph_edgemap_each_value,      0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "each_pair",       lemongraph_edgemap_each_pair,       0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "each",            lemongraph_edgemap_each_pair,       0); // in ext/lemongraph/edge_map.cc
+	rb_define_method(c_EdgeMap, "clear",           lemongraph_edgemap_clear,           0); // in ext/lemongraph/edge_map.cc
+}
+
+