lemongraph 0.0.1

data/ext/lemongraph/digraph.cc

@@ -0,0 +1,282 @@
+/* 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_Digraph;
+
+
+/* Document-class: LemonGraph::Digraph
+ * Directed graph.
+ */
+
+
+static void lemongraph_digraph_free(void *p)
+{
+	lemon::ListDigraph *g = (lemon::ListDigraph*)p;
+	delete g;
+}
+
+
+static size_t lemongraph_digraph_size(const void* p)
+{
+	return 0;
+}
+
+
+const rb_data_type_t lemongraph_digraph_type = {
+	.wrap_struct_name = "LemonGraph::Digraph",
+	.function = {
+		.dmark = NULL,
+		.dfree = lemongraph_digraph_free,
+		.dsize = lemongraph_digraph_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+VALUE lemongraph_digraph_alloc(VALUE klass)
+{
+	lemon::ListDigraph *g = new lemon::ListDigraph();
+	return TypedData_Wrap_Struct(klass, &lemongraph_digraph_type, g);
+}
+
+
+/* Adds a new node to the graph
+ * @return [Node] the newly created node
+ */
+VALUE lemongraph_digraph_add_node(VALUE self)
+{
+	lemon::ListDigraph::Node n = lemongraph_digraph_rb2ref(self).addNode();
+	return lemongraph_make_dinode(n, self);
+}
+
+
+void lemongraph_digraph_raise_if_not_valid_node(const lemon::ListDigraph& digraph, VALUE rbdigraph, VALUE node)
+{
+	if (rb_class_of(node) != c_DiNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_DiNode), rb_obj_classname(node));
+	}
+	if (rb_iv_get(node, "@graph") != rbdigraph)
+		rb_raise(rb_eRuntimeError, "this node does not belong to the graph");
+	if (!digraph.valid(lemongraph_rbdinode2dinode(node)))
+		rb_raise(rb_eRuntimeError, "node is not valid for the graph");
+}
+
+
+/* Adds a new arc to the graph with source node _s_ and target node _t_.
+ * @param s [Node] source node of the arc
+ * @param t [Node] target node of the arc
+ * @return [Arc] the newly created arc
+ */
+VALUE lemongraph_digraph_add_arc(VALUE self, VALUE s, VALUE t)
+{
+	lemon::ListDigraph &g = lemongraph_digraph_rb2ref(self);
+	lemongraph_digraph_raise_if_not_valid_node(g, self, s);
+	lemongraph_digraph_raise_if_not_valid_node(g, self, t);
+	lemon::ListDigraph::Arc a = g.addArc(
+			lemongraph_rbdinode2dinode(s),
+			lemongraph_rbdinode2dinode(t));
+	return lemongraph_make_diarc(a, self);
+}
+
+
+/* Test if the given node/arc is valid, i.e. it is a real node/arc of the graph.
+ * @param item [Node, Arc]
+ * @return [Boolean]
+ */
+VALUE lemongraph_digraph_item_is_valid(VALUE self, VALUE item)
+{
+	bool r = false;
+	VALUE klass = rb_class_of(item);
+	if (klass == c_DiNode) {
+		if (rb_iv_get(item, "@graph") == self)
+			r = lemongraph_digraph_rb2ref(self).valid(lemongraph_rbdinode2dinode(item));
+	}
+	else if (klass == c_DiArc) {
+		if (rb_iv_get(item, "@graph") == self)
+			r = lemongraph_digraph_rb2ref(self).valid(lemongraph_rbdiarc2diarc(item));
+	}
+	else
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " or a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_DiNode), rb_class_name(c_DiArc), rb_obj_classname(item));
+	return r ? Qtrue : Qfalse;
+}
+
+
+/* Erases the node or arc from the graph.
+ * @return [self]
+ * @overload erase(node)
+ *  Erases the given node along with its outgoing and incoming arcs from the graph.
+ *  @param node [Node] the node to erase
+ * @overload erase(arc)
+ *  Erases the given arc from the graph.
+ *  @param arc [Arc] the arc to erase
+ */
+VALUE lemongraph_digraph_erase_nodearc(VALUE self, VALUE item)
+{
+	VALUE klass = rb_class_of(item);
+	if (klass == c_DiNode) {
+		if (rb_iv_get(item, "@graph") != self)
+			rb_raise(rb_eRuntimeError, "this node does not belong to the graph");
+		lemongraph_digraph_rb2ref(self).erase(lemongraph_rbdinode2dinode(item));
+	}
+	else if (klass == c_DiArc) {
+		if (rb_iv_get(item, "@graph") != self)
+			rb_raise(rb_eRuntimeError, "this arc does not belong to the graph");
+		lemongraph_digraph_rb2ref(self).erase(lemongraph_rbdiarc2diarc(item));
+	}
+	else
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " or a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_DiNode), rb_class_name(c_DiArc), rb_obj_classname(item));
+	return self;
+}
+
+
+/* Erases all nodes and arcs from the graph
+ * @return [self]
+ */
+VALUE lemongraph_digraph_clear(VALUE self)
+{
+	lemongraph_digraph_rb2ref(self).clear();
+	return self;
+}
+
+
+/* Number of nodes in the graph.
+ * @return [Integer]
+ */
+VALUE lemongraph_digraph_nb_nodes(VALUE self)
+{
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(self);
+	return INT2NUM(lemon::countNodes(g));
+}
+
+
+/* Returns an array containing all the nodes of the graph.
+ * @return [Array<Node>]
+ */
+VALUE lemongraph_digraph_nodes(VALUE self)
+{
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(self);
+	VALUE a = rb_ary_new_capa(lemon::countNodes(g));
+	for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n)
+		rb_ary_push(a, lemongraph_make_dinode(n, self));
+	return a;
+}
+
+
+static VALUE lemongraph_digraph_nodeenum_nbnodes(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_digraph_nb_nodes(obj);
+}
+
+
+/* Calls the block, if given, once for each {Node} in the graph.
+ * The nodes are passed as parameters to the block.
+ *
+ * Returns _self_, or, if no block is given, an Enumerator is returned.
+ * @return [self, Enumerator]
+ * @overload each_node
+ *  @yieldparam node [Node]
+ *  @return [self]
+ * @overload each_node
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_digraph_each_node(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_digraph_nodeenum_nbnodes);
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(self);
+	for (lemon::ListDigraph::NodeIt n(g); n != lemon::INVALID; ++n)
+		rb_yield(lemongraph_make_dinode(n, self));
+	return self;
+}
+
+
+/* Number of arcs in the graph.
+ * @return [Integer]
+ */
+VALUE lemongraph_digraph_nb_arcs(VALUE self)
+{
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(self);
+	return INT2NUM(lemon::countArcs(g));
+}
+
+
+/* Returns an array containing all the arcs of the graph.
+ * @return [Array<Arc>]
+ */
+VALUE lemongraph_digraph_arcs(VALUE self)
+{
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(self);
+	VALUE ar = rb_ary_new_capa(lemon::countArcs(g));
+	for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a)
+		rb_ary_push(ar, lemongraph_make_diarc(a, self));
+	return ar;
+}
+
+
+static VALUE lemongraph_digraph_arcenum_nbarcs(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_digraph_nb_arcs(obj);
+}
+
+
+/* Calls the block, if given, once for each {Arc} in the graph.
+ * 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_arc
+ *  @yieldparam arc [Arc]
+ *  @return [self]
+ * @overload each_arc
+ *  @return [Enumerator]
+ */
+VALUE lemongraph_digraph_each_arc(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_digraph_arcenum_nbarcs);
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(self);
+	for (lemon::ListDigraph::ArcIt a(g); a != lemon::INVALID; ++a)
+		rb_yield(lemongraph_make_diarc(a, self));
+	return self;
+}
+
+
+/* Method called by _dup_ and _clone_ methods.
+ * @return [self]
+ */
+VALUE lemongraph_digraph_initialize_copy(VALUE self, VALUE orig)
+{
+	rb_call_super(1, &orig);
+	lemon::ListDigraph& from = lemongraph_digraph_rb2ref(orig);
+	lemon::ListDigraph& to =   lemongraph_digraph_rb2ref(self);
+	lemon::digraphCopy(from, to).run();
+	return self;
+}
+
+

data/ext/lemongraph/digraph_arc.cc

@@ -0,0 +1,153 @@
+/* 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_DiArc;
+
+
+/* Document-class: LemonGraph::Digraph::Arc
+ * Arc of a {Digraph}, from a source {Node} to a target {Node}.
+ */
+
+
+VALUE lemongraph_make_diarc(const lemon::ListDigraph::Arc& arc, VALUE graph)
+{
+	if (arc == lemon::INVALID)
+		return Qnil;
+	VALUE args[2] = {INT2NUM(lemon::ListDigraph::id(arc)), graph};
+	return rb_class_new_instance(2, args, c_DiArc);
+}
+
+
+/* @!visibility private
+ */
+VALUE lemongraph_diarc_initialize(VALUE self, VALUE id, VALUE graph)
+{
+	if (rb_obj_is_kind_of(graph, c_Digraph) != Qtrue) {
+		rb_raise(rb_eRuntimeError, "expecting a %" PRIsVALUE " as graph, not a %s",
+				rb_class_name(c_Digraph), rb_obj_classname(graph));
+	}
+	VALUE args[2] = {id, graph};
+	return rb_call_super(2, args);
+}
+
+
+/* Erases the arc from the graph it belongs to.
+ * @return [self]
+ */
+VALUE lemongraph_diarc_erase(VALUE self)
+{
+	lemongraph_digraph_rb2ref(rb_iv_get(self, "@graph")).erase(lemongraph_rbdiarc2diarc(self));
+	return self;
+}
+
+
+/* Test if the arc is valid, i.e. it is a real arc of the graph it belons to.
+ * @return [Boolean]
+ */
+VALUE lemongraph_diarc_is_valid(VALUE self)
+{
+	return lemongraph_digraph_rb2ref(rb_iv_get(self, "@graph")).valid(lemongraph_rbdiarc2diarc(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Changes the target node of the arc a to _node_.
+ * @param node [Node] the arc's new target node
+ * @return [self]
+ */
+VALUE lemongraph_diarc_change_target(VALUE self, VALUE node)
+{
+	if (rb_class_of(node) != c_DiNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_DiNode), rb_obj_classname(node));
+	}
+	VALUE graph = rb_iv_get(self, "@graph");
+	if (rb_iv_get(node, "@graph") != graph)
+		rb_raise(rb_eRuntimeError, "arc and node not from the sams graph");
+	lemongraph_digraph_rb2ref(graph).changeTarget(lemongraph_rbdiarc2diarc(self), lemongraph_rbdinode2dinode(node));
+	return self;
+}
+
+
+/* Changes the source node of the arc a to _node_.
+ * @param node [Node] the arc's new source node
+ * @return [self]
+ */
+VALUE lemongraph_diarc_change_source(VALUE self, VALUE node)
+{
+	if (rb_class_of(node) != c_DiNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_DiNode), rb_obj_classname(node));
+	}
+	VALUE graph = rb_iv_get(self, "@graph");
+	if (rb_iv_get(node, "@graph") != graph)
+		rb_raise(rb_eRuntimeError, "arc and node not from the sams graph");
+	lemongraph_digraph_rb2ref(graph).changeSource(lemongraph_rbdiarc2diarc(self), lemongraph_rbdinode2dinode(node));
+	return self;
+}
+
+
+/* Returns the source node of the arc.
+ * @return [Node]
+ */
+VALUE lemongraph_diarc_source(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListDigraph::Node n = lemongraph_digraph_rb2ref(g).source(lemongraph_rbdiarc2diarc(self));
+	return lemongraph_make_dinode(n, g);
+}
+
+
+/* Returns the target node of the arc.
+ * @return [Node]
+ */
+VALUE lemongraph_diarc_target(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListDigraph::Node n = lemongraph_digraph_rb2ref(g).target(lemongraph_rbdiarc2diarc(self));
+	return lemongraph_make_dinode(n, g);
+}
+
+
+/* Reverses the direction of the given arc.
+ * @return [self]
+ */
+VALUE lemongraph_diarc_reverse(VALUE self)
+{
+	lemongraph_digraph_rb2ref(rb_iv_get(self, "@graph")).reverseArc(lemongraph_rbdiarc2diarc(self));
+	return self;
+}
+
+
+/* Splits the arc.
+ * First, a new node _v_ is added to the graph,
+ * then the target node of the original arc is set to _v_.
+ * Finally, an arc from _v_ to the original target is added.
+ * @return [Node] the newly created node
+ */
+VALUE lemongraph_diarc_split(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListDigraph::Node n = lemongraph_digraph_rb2ref(g).split(lemongraph_rbdiarc2diarc(self));
+	return lemongraph_make_dinode(n, g);
+}
+
+

data/ext/lemongraph/digraph_node.cc

@@ -0,0 +1,277 @@
+/* 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_DiNode;
+
+
+/* Document-class: LemonGraph::Digraph::Node
+ * Node of a {Digraph}.
+ */
+
+
+VALUE lemongraph_make_dinode(const lemon::ListDigraph::Node& node, VALUE graph)
+{
+	if (node == lemon::INVALID)
+		return Qnil;
+	VALUE args[2] = {INT2NUM(lemon::ListDigraph::id(node)), graph};
+	return rb_class_new_instance(2, args, c_DiNode);
+}
+
+
+/* @!visibility private
+ */
+VALUE lemongraph_dinode_initialize(VALUE self, VALUE id, VALUE graph)
+{
+	if (rb_obj_is_kind_of(graph, c_Digraph) != Qtrue) {
+		rb_raise(rb_eRuntimeError, "expecting a %" PRIsVALUE " as graph, not a %s",
+				rb_class_name(c_Digraph), 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_dinode_is_valid(VALUE self)
+{
+	return lemongraph_digraph_rb2ref(rb_iv_get(self, "@graph")).valid(lemongraph_rbdinode2dinode(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Erases the node from the graph it belongs to.
+ * @return [self]
+ */
+VALUE lemongraph_dinode_erase(VALUE self)
+{
+	lemongraph_digraph_rb2ref(rb_iv_get(self, "@graph")).erase(lemongraph_rbdinode2dinode(self));
+	return self;
+}
+
+
+/* Splits the node.
+ * First, a new node is added to the digraph,
+ * then the source of each outgoing arc of _self_ is moved to this new node.
+ * If the parameter _connect_ is _true_ (this is the default),
+ * then a new arc from _self_ to the newly created node is also added.
+ * @overload split(connect = true)
+ *  @param connect [Boolean] whether to connect _self_ to the new node
+ * @return [Node] the newly created node.
+ */
+VALUE lemongraph_dinode_split(int argc, VALUE *argv, VALUE self)
+{
+	bool connect = true;
+	if (argc == 1)
+		connect = (argv[0] != Qnil && argv[0] != Qfalse);
+	else if (argc > 1)
+		rb_raise(rb_eArgError, "wrong number of arguments (given %d, expected 0..1)", argc);
+	VALUE rbgraph = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbgraph);
+	lemon::ListDigraph::Node n = g.split(lemongraph_rbdinode2dinode(self), connect);
+	return lemongraph_make_dinode(n, rbgraph);
+}
+
+
+/* Contracts _self_ into the given node.
+ * _self_ is removed, but instead of deleting its incident arcs, 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_dinode_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::ListDigraph &g = lemongraph_digraph_rb2ref(rbg);
+	lemongraph_digraph_raise_if_not_valid_node(g, rbg, self);
+	lemongraph_digraph_raise_if_not_valid_node(g, rbg, other);
+	g.contract(lemongraph_rbdinode2dinode(other), lemongraph_rbdinode2dinode(self), remove_new_loops);
+	return other;
+}
+
+
+/* Number of incoming arcs to the node.
+ * @return [Integer]
+ */
+VALUE lemongraph_dinode_nb_inarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbg);
+	lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(self);
+	return INT2NUM(lemon::countInArcs(g, n));
+}
+
+
+/* Returns an array containing all the incoming arcs to the node.
+ * @return [Array<Arc>]
+ */
+VALUE lemongraph_dinode_inarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbg);
+	lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(self);
+	VALUE ar = rb_ary_new_capa(lemon::countInArcs(g, n));
+	for (lemon::ListDigraph::InArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_ary_push(ar, lemongraph_make_diarc(a, rbg));
+	return ar;
+}
+
+
+static VALUE lemongraph_dinode_inarcenum_nbinarcs(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_dinode_nb_inarcs(obj);
+}
+
+
+/* Calls the block, if given, once for each incoming {Arc} to 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_dinode_each_inarc(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_dinode_inarcenum_nbinarcs);
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbg);
+	lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(self);
+	for (lemon::ListDigraph::InArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_yield(lemongraph_make_diarc(a, rbg));
+	return self;
+}
+
+
+
+/* Number of outgoing arcs from the node.
+ * @return [Integer]
+ */
+VALUE lemongraph_dinode_nb_outarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbg);
+	lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(self);
+	return INT2NUM(lemon::countOutArcs(g, n));
+}
+
+
+/* Returns an array containing all the outgoing arcs from the node.
+ * @return [Array<Arc>]
+ */
+VALUE lemongraph_dinode_outarcs(VALUE self)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbg);
+	lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(self);
+	VALUE ar = rb_ary_new_capa(lemon::countOutArcs(g, n));
+	for (lemon::ListDigraph::OutArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_ary_push(ar, lemongraph_make_diarc(a, rbg));
+	return ar;
+}
+
+
+static VALUE lemongraph_dinode_outarcenum_nboutarcs(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_dinode_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_dinode_each_outarc(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_dinode_outarcenum_nboutarcs);
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbg);
+	lemon::ListDigraph::Node n = lemongraph_rbdinode2dinode(self);
+	for (lemon::ListDigraph::OutArcIt a(g, n); a != lemon::INVALID; ++a)
+		rb_yield(lemongraph_make_diarc(a, rbg));
+	return self;
+}
+
+
+/* Creates an {Arc} from source _self_ to target _target_.
+ * @param target [Node] target node of the arc
+ * @return [Arc]
+ */
+VALUE lemongraph_dinode_arc_to(VALUE self, VALUE target)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	return lemongraph_digraph_add_arc(rbg, self, target);
+}
+
+
+/* Creates an {Arc} from source _source_ to target _self_.
+ * @param source [Node] source node of the arc
+ * @return [Arc]
+ */
+VALUE lemongraph_dinode_arc_from(VALUE self, VALUE source)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	return lemongraph_digraph_add_arc(rbg, source, self);
+}
+
+
+/* Returns the node opposite to _self_ on _arc_.
+ * Returns _nil_ if _arc_ is not incident to _self_.
+ * @param arc [Arc]
+ * @return [Node]
+ */
+VALUE lemongraph_dinode_opposite(VALUE self, VALUE arc)
+{
+	VALUE rbg = rb_iv_get(self, "@graph");
+	lemon::ListDigraph& g = lemongraph_digraph_rb2ref(rbg);
+	if (rb_class_of(arc) != c_DiArc) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_DiArc), rb_obj_classname(arc));
+	}
+	if (rb_iv_get(arc, "@graph") != rbg)
+		rb_raise(rb_eRuntimeError, "node and arc are not from the same graph");
+	return lemongraph_make_dinode(g.oppositeNode(lemongraph_rbdinode2dinode(self), lemongraph_rbdiarc2diarc(arc)), rbg);
+}
+
+