lemongraph 0.0.1

data/ext/lemongraph/extconf.rb

@@ -0,0 +1,53 @@
+require 'mkmf'
+
+dev = false
+llvm = false
+
+unless have_library('lemon') then
+  #abort "-----\nLEMON is missing. Please install LEMON (eg \'sudo apt install liblemon-dev\').\n-----"
+  ext_dir = File.absolute_path(File.join('..', '..'), __FILE__)
+  lemon_src_dir = File.join(ext_dir, 'lemon-1.3.1')
+  lemon_build_dir = File.join(lemon_src_dir, 'build')
+  lemon_install_dir = File.join(lemon_src_dir, 'install')
+
+  abort "-----\ncmake is missing. Please install cmake (eg \'sudo apt install cmake\').\n-----" unless find_executable('cmake')
+
+  unless File.exist? lemon_install_dir then
+    Dir.mkdir lemon_build_dir
+
+    Dir.chdir(lemon_build_dir) do
+      cmd = "cmake -DCMAKE_INSTALL_PREFIX='#{lemon_install_dir}' -DCMAKE_BUILD_TYPE=Release .."
+      message cmd + "\n"
+      abort("-----\n#{caller[0]}\nCannot cmake lemon-1.3.1.\n-----") unless system cmd
+
+      cmd = "make"
+      message cmd + "\n"
+      abort("-----\n#{caller[0]}\nCannot make lemon-1.3.1.\n-----") unless system cmd
+
+      cmd = "make install"
+      message cmd + "\n"
+      abort("-----\n#{caller[0]}\nCannot install lemon-1.3.1.\n-----") unless system cmd
+    end
+  end
+
+  append_cppflags "-I'#{File.join(lemon_install_dir, 'include')}'"
+end
+
+if llvm then
+  MakeMakefile::CONFIG['CC'] = 'clang'
+  MakeMakefile::CONFIG['CXX'] = 'clang++'
+  append_cppflags('-Wall -Wextra -Wdeprecated-declarations -Wmisleading-indentation -Wpointer-arith -Wwrite-strings -Wmissing-noreturn -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wunused-variable') if dev
+  $CPPFLAGS << ' -fdeclspec'
+else
+  append_cppflags('-Wall -Wextra -Wdeprecated-declarations -Wduplicated-cond -Wmisleading-indentation -Wpointer-arith -Wwrite-strings -Wimplicit-fallthrough=0 -Wmissing-noreturn -Wno-cast-function-type -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-packed-bitfield-compat -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable') if dev
+end
+
+append_cppflags('-fvisibility=hidden')
+
+append_ldflags('-Wl,--version-script=lemongraph.map')
+
+
+create_makefile 'lemongraph/lemongraph'
+
+File.write('Makefile', File.read('Makefile').sub(/^V = 0$/, 'V = 1')) if dev
+

data/ext/lemongraph/graph.cc

@@ -0,0 +1,351 @@
+/* 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_Graph;
+
+
+/* Document-class: LemonGraph::Graph
+ * Undirected graph.
+ *
+ * The undirected graphs fulfill the concept of directed graphs,
+ * since each edge can also be regarded as two oppositely directed arcs.
+ * Undirected graphs provide an {Edge} type for the undirected edges and an {Arc} type for the directed arcs.
+ *
+ * In LEMON, each undirected edge has an inherent orientation.
+ * Thus it can define if an arc is forward or backward oriented in an undirected graph with respect to this default oriantation of the represented edge.
+ * With the direction() and direct() functions the direction of an arc can be obtained and set, respectively.
+ *
+ * Only nodes and edges can be added to or removed from an undirected graph and the corresponding arcs are added or removed automatically.
+ */
+
+
+static void lemongraph_graph_free(void *p)
+{
+	lemon::ListGraph *g = (lemon::ListGraph*)p;
+	delete g;
+}
+
+
+static size_t lemongraph_graph_size(const void* p)
+{
+	return 0;
+}
+
+
+const rb_data_type_t lemongraph_graph_type = {
+	.wrap_struct_name = "LemonGraph::Graph",
+	.function = {
+		.dmark = NULL,
+		.dfree = lemongraph_graph_free,
+		.dsize = lemongraph_graph_size,
+	},
+	.parent = NULL,
+	.data = NULL,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY
+};
+
+
+VALUE lemongraph_graph_alloc(VALUE klass)
+{
+	lemon::ListGraph *g = new lemon::ListGraph();
+	return TypedData_Wrap_Struct(klass, &lemongraph_graph_type, g);
+}
+
+
+/* Method called by _dup_ and _clone_ methods.
+ * @return [self]
+ */
+VALUE lemongraph_graph_initialize_copy(VALUE self, VALUE orig)
+{
+
+	rb_call_super(1, &orig);
+	lemon::ListGraph& from = lemongraph_graph_rb2ref(orig);
+	lemon::ListGraph& to =   lemongraph_graph_rb2ref(self);
+	lemon::graphCopy(from, to).run();
+	return self;
+}
+
+
+/* Adds a new node to the graph
+ * @return [Node] the newly created node
+ */
+VALUE lemongraph_graph_add_node(VALUE self)
+{
+	lemon::ListGraph::Node n = lemongraph_graph_rb2ref(self).addNode();
+	return lemongraph_make_unnode(n, self);
+}
+
+
+void lemongraph_graph_raise_if_not_valid_node(const lemon::ListGraph& graph, VALUE rbgraph, VALUE node)
+{
+	if (rb_class_of(node) != c_UnNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_UnNode), rb_obj_classname(node));
+	}
+	if (rb_iv_get(node, "@graph") != rbgraph)
+		rb_raise(rb_eRuntimeError, "this node does not belong to the graph");
+	if (!graph.valid(lemongraph_rbunnode2unnode(node)))
+		rb_raise(rb_eRuntimeError, "node is not valid for the graph");
+}
+
+
+/* Adds a new {Edge} to the graph with between nodes _u_ and _v_.
+ * @param u [Node]
+ * @param v [Node]
+ * @return [Edge] the newly created edge
+ */
+VALUE lemongraph_graph_add_edge(VALUE self, VALUE u, VALUE v)
+{
+	lemon::ListGraph &g = lemongraph_graph_rb2ref(self);
+	lemongraph_graph_raise_if_not_valid_node(g, self, u);
+	lemongraph_graph_raise_if_not_valid_node(g, self, v);
+	lemon::ListGraph::Edge e = g.addEdge(
+			lemongraph_rbunnode2unnode(u),
+			lemongraph_rbunnode2unnode(v));
+	return lemongraph_make_unedge(e, self);
+}
+
+
+/* Test if the given node edge or arc is valid, i.e. it is a real node/edge/arc of the graph.
+ * @param item [Node, Edge, Arc]
+ * @return [Boolean]
+ */
+VALUE lemongraph_graph_item_is_valid(VALUE self, VALUE item)
+{
+	bool r = false;
+	VALUE klass = rb_class_of(item);
+	if (klass == c_UnNode) {
+		if (rb_iv_get(item, "@graph") == self)
+			r = lemongraph_graph_rb2ref(self).valid(lemongraph_rbunnode2unnode(item));
+	}
+	else if (klass == c_UnEdge) {
+		if (rb_iv_get(item, "@graph") == self)
+			r = lemongraph_graph_rb2ref(self).valid(lemongraph_rbunedge2unedge(item));
+	}
+	else if (klass == c_UnArc) {
+		if (rb_iv_get(item, "@graph") == self)
+			r = lemongraph_graph_rb2ref(self).valid(lemongraph_rbunarc2unarc(item));
+	}
+	else
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", a %" PRIsVALUE " or a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_UnNode), rb_class_name(c_UnEdge), rb_class_name(c_UnArc), rb_obj_classname(item));
+	return r ? Qtrue : Qfalse;
+}
+
+
+/* Erases the node or edge from the graph.
+ * @return [self]
+ * @overload erase(node)
+ *  Erases the given node along with its incidents edges from the graph.
+ *  @param node [Node] the node to erase
+ * @overload erase(edge)
+ *  Erases the given edge from the graph.
+ *  @param arc [Edge] the edge to erase
+ */
+VALUE lemongraph_graph_erase_item(VALUE self, VALUE item)
+{
+	VALUE klass = rb_class_of(item);
+	if (klass == c_UnNode) {
+		if (rb_iv_get(item, "@graph") != self)
+			rb_raise(rb_eRuntimeError, "this node does not belong to the graph");
+		lemongraph_graph_rb2ref(self).erase(lemongraph_rbunnode2unnode(item));
+	}
+	else if (klass == c_UnEdge) {
+		if (rb_iv_get(item, "@graph") != self)
+			rb_raise(rb_eRuntimeError, "this edge does not belong to the graph");
+		lemongraph_graph_rb2ref(self).erase(lemongraph_rbunedge2unedge(item));
+	}
+	else if (klass == c_UnArc)
+		rb_raise(rb_eTypeError, "cannot erase a %" PRIsVALUE " from a %" PRIsVALUE, rb_class_name(c_UnArc), rb_class_name(c_Graph));
+	else
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE " or a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_UnNode), rb_class_name(c_UnEdge), rb_obj_classname(item));
+	return self;
+}
+
+
+/* Erases all nodes and edges from the graph
+ * @return [self]
+ */
+VALUE lemongraph_graph_clear(VALUE self)
+{
+	lemongraph_graph_rb2ref(self).clear();
+	return self;
+}
+
+
+/* Number of nodes in the graph.
+ * @return [Integer]
+ */
+VALUE lemongraph_graph_nb_nodes(VALUE self)
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	return INT2NUM(lemon::countNodes(g));
+}
+
+
+/* Returns an array containing all the nodes of the graph.
+ * @return [Array<Node>]
+ */
+VALUE lemongraph_graph_nodes(VALUE self)
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	VALUE a = rb_ary_new_capa(lemon::countNodes(g));
+	for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n)
+		rb_ary_push(a, lemongraph_make_unnode(n, self));
+	return a;
+}
+
+
+static VALUE lemongraph_graph_nodeenum_nbnodes(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_graph_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_graph_each_node(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_graph_nodeenum_nbnodes);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	for (lemon::ListGraph::NodeIt n(g); n != lemon::INVALID; ++n)
+		rb_yield(lemongraph_make_unnode(n, self));
+	return self;
+}
+
+
+/* Number of edges in the graph.
+ * @return [Integer]
+ */
+VALUE lemongraph_graph_nb_edges(VALUE self)
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	return INT2NUM(lemon::countEdges(g));
+}
+
+
+/* Returns an array containing all the edges of the graph.
+ * @return [Array<Edge>]
+ */
+VALUE lemongraph_graph_edges(VALUE self)
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	VALUE a = rb_ary_new_capa(lemon::countEdges(g));
+	for (lemon::ListGraph::EdgeIt e(g); e != lemon::INVALID; ++e)
+		rb_ary_push(a, lemongraph_make_unedge(e, self));
+	return a;
+}
+
+
+static VALUE lemongraph_graph_edgeenum_nbedges(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_graph_nb_edges(obj);
+}
+
+
+/* Calls the block, if given, once for each {Edge} in the graph.
+ * 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_graph_each_edge(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_graph_edgeenum_nbedges);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	for (lemon::ListGraph::EdgeIt n(g); n != lemon::INVALID; ++n)
+		rb_yield(lemongraph_make_unedge(n, self));
+	return self;
+}
+
+
+/* Number of arcs in the graph.
+ * @return [Integer]
+ */
+VALUE lemongraph_graph_nb_arcs(VALUE self)
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	return INT2NUM(lemon::countArcs(g));
+}
+
+
+/* Returns an array containing all the arcs of the graph.
+ * @return [Array<Arc>]
+ */
+VALUE lemongraph_graph_arcs(VALUE self)
+{
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	VALUE ar = rb_ary_new_capa(lemon::countArcs(g));
+	for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a)
+		rb_ary_push(ar, lemongraph_make_unarc(a, self));
+	return ar;
+}
+
+
+static VALUE lemongraph_graph_arcenum_nbarcs(VALUE obj, VALUE args, VALUE eobj)
+{
+	(void)args;
+	(void)eobj;
+	return lemongraph_graph_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_graph_each_arc(VALUE self)
+{
+	RETURN_SIZED_ENUMERATOR(self, 0, 0, lemongraph_graph_arcenum_nbarcs);
+	lemon::ListGraph& g = lemongraph_graph_rb2ref(self);
+	for (lemon::ListGraph::ArcIt a(g); a != lemon::INVALID; ++a)
+		rb_yield(lemongraph_make_unarc(a, self));
+	return self;
+}
+
+

data/ext/lemongraph/graph_arc.cc

@@ -0,0 +1,95 @@
+/* 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_UnArc;
+
+
+/* Document-class: LemonGraph::Graph::Arc
+ * Arc of a {Graph}, from a source {Node} to a target {Node}.
+ * Each {Edge} of a {Graph} is composed of two arcs in opposite direction.
+ */
+
+
+VALUE lemongraph_make_unarc(const lemon::ListGraph::Arc& arc, VALUE graph)
+{
+	if (arc == lemon::INVALID)
+		return Qnil;
+	VALUE args[2] = {INT2NUM(lemon::ListGraph::id(arc)), graph};
+	return rb_class_new_instance(2, args, c_UnArc);
+}
+
+
+/* @!visibility private
+ */
+VALUE lemongraph_unarc_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 arc is valid, i.e. it is a real arc of the graph it belons to.
+ * @return [Boolean]
+ */
+VALUE lemongraph_unarc_is_valid(VALUE self)
+{
+	return lemongraph_graph_rb2ref(rb_iv_get(self, "@graph")).valid(lemongraph_rbunarc2unarc(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Returns the source node of the arc.
+ * @return [Node]
+ */
+VALUE lemongraph_unarc_source(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListGraph::Node n = lemongraph_graph_rb2ref(g).source(lemongraph_rbunarc2unarc(self));
+	return lemongraph_make_unnode(n, g);
+}
+
+
+/* Returns the target node of the arc.
+ * @return [Node]
+ */
+VALUE lemongraph_unarc_target(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListGraph::Node n = lemongraph_graph_rb2ref(g).target(lemongraph_rbunarc2unarc(self));
+	return lemongraph_make_unnode(n, g);
+}
+
+
+/* Returns the arc corresponding to the same edge as _self_ but in the opposite orientation.
+ * @return [Arc]
+ */
+VALUE lemongraph_unarc_opposite(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListGraph::Arc a = lemongraph_graph_rb2ref(g).oppositeArc(lemongraph_rbunarc2unarc(self));
+	return lemongraph_make_unarc(a, g);
+}
+
+

data/ext/lemongraph/graph_edge.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_UnEdge;
+
+
+/* Document-class: LemonGraph::Graph::Edge
+ * Edge of a {Graph}, between two {Node}s _u_ and _v_.
+ */
+
+
+VALUE lemongraph_make_unedge(const lemon::ListGraph::Edge& edge, VALUE graph)
+{
+	if (edge == lemon::INVALID)
+		return Qnil;
+	VALUE args[2] = {INT2NUM(lemon::ListGraph::id(edge)), graph};
+	return rb_class_new_instance(2, args, c_UnEdge);
+}
+
+
+/* @!visibility private
+ */
+VALUE lemongraph_unedge_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);
+}
+
+
+/* Erases the edge from the graph it belongs to.
+ * @return [self]
+ */
+VALUE lemongraph_unedge_erase(VALUE self)
+{
+	lemongraph_graph_rb2ref(rb_iv_get(self, "@graph")).erase(lemongraph_rbunedge2unedge(self));
+	return self;
+}
+
+
+/* Test if the edge is valid, i.e. it is a real edge of the graph it belons to.
+ * @return [Boolean]
+ */
+VALUE lemongraph_unedge_is_valid(VALUE self)
+{
+	return lemongraph_graph_rb2ref(rb_iv_get(self, "@graph")).valid(lemongraph_rbunedge2unedge(self)) ? Qtrue : Qfalse;
+}
+
+
+/* Returns the first node of the edge.
+ * @return [Node]
+ */
+VALUE lemongraph_unedge_u(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListGraph::Node n = lemongraph_graph_rb2ref(g).u(lemongraph_rbunedge2unedge(self));
+	return lemongraph_make_unnode(n, g);
+}
+
+
+/* Returns the second node of the edge.
+ * @return [Node]
+ */
+VALUE lemongraph_unedge_v(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListGraph::Node n = lemongraph_graph_rb2ref(g).v(lemongraph_rbunedge2unedge(self));
+	return lemongraph_make_unnode(n, g);
+}
+
+
+/* Changes the first node of the edge to _node_.
+ * @param node [Node] the edge's new _u_ node
+ * @return [node]
+ */
+VALUE lemongraph_unedge_change_u(VALUE self, VALUE node)
+{
+	if (rb_class_of(node) != c_UnNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_UnNode), rb_obj_classname(node));
+	}
+	VALUE graph = rb_iv_get(self, "@graph");
+	if (rb_iv_get(node, "@graph") != graph)
+		rb_raise(rb_eRuntimeError, "edge and node not from the sams graph");
+	lemongraph_graph_rb2ref(graph).changeU(lemongraph_rbunedge2unedge(self), lemongraph_rbunnode2unnode(node));
+	return self;
+}
+
+
+/* Changes the second node of the edge to _node_.
+ * @param node [Node] the edge's new _v_ node
+ * @return [node]
+ */
+VALUE lemongraph_unedge_change_v(VALUE self, VALUE node)
+{
+	if (rb_class_of(node) != c_UnNode) {
+		rb_raise(rb_eTypeError, "expecting a %" PRIsVALUE ", not a %s",
+				rb_class_name(c_UnNode), rb_obj_classname(node));
+	}
+	VALUE graph = rb_iv_get(self, "@graph");
+	if (rb_iv_get(node, "@graph") != graph)
+		rb_raise(rb_eRuntimeError, "edge and node not from the sams graph");
+	lemongraph_graph_rb2ref(graph).changeV(lemongraph_rbunedge2unedge(self), lemongraph_rbunnode2unnode(node));
+	return self;
+}
+
+
+/* Returns the {Arc} that represents the edge and whose direction is
+ * the same as the inherent orientation of _self_ (from _u_ to _v_).
+ * @return [Arc]
+ */
+VALUE lemongraph_unedge_arc1(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListGraph::Arc a = lemongraph_graph_rb2ref(g).direct(lemongraph_rbunedge2unedge(self), true);
+	return lemongraph_make_unarc(a, g);
+}
+
+
+/* Returns the {Arc} that represents the edge and whose direction is
+ * the opposite as the inherent orientation of _self_ (so, from _v_ to _u_).
+ * @return [Arc]
+ */
+VALUE lemongraph_unedge_arc2(VALUE self)
+{
+	VALUE g = rb_iv_get(self, "@graph");
+	lemon::ListGraph::Arc a = lemongraph_graph_rb2ref(g).direct(lemongraph_rbunedge2unedge(self), false);
+	return lemongraph_make_unarc(a, g);
+}
+
+