Diff [68fe66e2b34ac0cecdff8a90bf1e5c8cd1aaae1e:04c0631fd33241997b26542eec78715709d11003] for / – LEMON

.hgignore

-                      r385
+                      r456
 .deps/*
 demo/*.eps
+m4/libtool.m4
+m4/ltoptions.m4
+m4/ltsugar.m4
+m4/ltversion.m4
+m4/lt~obsolete.m4
 syntax: regexp

LICENSE

r107	r440
2	2	copyright/license.
3	3
4		Copyright (C) 2003-2008 Egervary Jeno Kombinatorikus Optimalizalasi
	4	Copyright (C) 2003-2009 Egervary Jeno Kombinatorikus Optimalizalasi
5	5	Kutatocsoport (Egervary Combinatorial Optimization Research Group,
6	6	EGRES).

configure.ac

-                      r363
+                      r459
 dnl Checks for libraries.
+#LX_CHECK_GLPK
+#LX_CHECK_CPLEX
+#LX_CHECK_SOPLEX
+LX_CHECK_GLPK
+LX_CHECK_CPLEX
+LX_CHECK_SOPLEX
+LX_CHECK_CLP
+AM_CONDITIONAL([HAVE_LP], [test x"$lx_lp_found" = x"yes"])
+AM_CONDITIONAL([HAVE_MIP], [test x"$lx_mip_found" = x"yes"])
 dnl Disable/enable building the demo programs.
 …
 echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS
 echo
+#echo GLPK support.................. : $lx_glpk_found
+#echo CPLEX support................. : $lx_cplex_found
+#echo SOPLEX support................ : $lx_soplex_found
+#echo
+echo GLPK support.................. : $lx_glpk_found
+echo CPLEX support................. : $lx_cplex_found
+echo SOPLEX support................ : $lx_soplex_found
+echo CLP support................... : $lx_clp_found
+echo
 echo Build demo programs........... : $enable_demo
 echo Build additional tools........ : $enable_tools

demo/arg_parser_demo.cc

r311	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

demo/graph_to_eps_demo.cc

-                      r313
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     coords(coords).
     title("Sample .eps figure").
     copyright("(C) 2003-2008 LEMON Project").
+    copyright("(C) 2003-2009 LEMON Project").
     run();
 …
     coords(coords).
     title("Sample .eps figure").
     copyright("(C) 2003-2008 LEMON Project").
+    copyright("(C) 2003-2009 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeScale(2).nodeSizes(sizes).
 …
   graphToEps(g,"graph_to_eps_demo_out_3_arr.eps").
     title("Sample .eps figure (with arrowheads)").
     copyright("(C) 2003-2008 LEMON Project").
+    copyright("(C) 2003-2009 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeColors(composeMap(palette,colors)).
 …
   graphToEps(g,"graph_to_eps_demo_out_4_par.eps").
     title("Sample .eps figure (parallel arcs)").
     copyright("(C) 2003-2008 LEMON Project").
+    copyright("(C) 2003-2009 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeShapes(shapes).
 …
   graphToEps(g,"graph_to_eps_demo_out_5_par_arr.eps").
     title("Sample .eps figure (parallel arcs and arrowheads)").
     copyright("(C) 2003-2008 LEMON Project").
+    copyright("(C) 2003-2009 LEMON Project").
     absoluteNodeSizes().absoluteArcWidths().
     nodeScale(2).nodeSizes(sizes).
 …
   graphToEps(g,"graph_to_eps_demo_out_6_par_arr_a4.eps").
     title("Sample .eps figure (fits to A4)").
     copyright("(C) 2003-2008 LEMON Project").
+    copyright("(C) 2003-2009 LEMON Project").
     scaleToA4().
     absoluteNodeSizes().absoluteArcWidths().
 …
     scale(60).
     title("Sample .eps figure (Palette demo)").
     copyright("(C) 2003-2008 LEMON Project").
+    copyright("(C) 2003-2009 LEMON Project").
     coords(hcoords).
     absoluteNodeSizes().absoluteArcWidths().

demo/lgf_demo.cc

r294	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/coding_style.dox

r210	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/dirs.dox

-                      r318
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 \brief Auxiliary tools for implementation.
 This directory contains some auxiliary classes for implementing graphs,
+This directory contains some auxiliary classes for implementing graphs,
 maps and some other classes.
 As a user you typically don't have to deal with these files.

doc/groups.dox

-                      r418
+                      r455
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /**
 @defgroup graph_adaptors Adaptor Classes for graphs
+@defgroup graph_adaptors Adaptor Classes for Graphs
 @ingroup graphs
+\brief This group contains several adaptor classes for digraphs and graphs
+\brief Adaptor classes for digraphs and graphs
+This group contains several useful adaptor classes for digraphs and graphs.
 The main parts of LEMON are the different graph structures, generic
 graph algorithms, graph concepts which couple these, and graph
+graph algorithms, graph concepts, which couple them, and graph
 adaptors. While the previous notions are more or less clear, the
 latter one needs further explanation. Graph adaptors are graph classes
 …
 A short example makes this much clearer.  Suppose that we have an
 instance \c g of a directed graph type say ListDigraph and an algorithm
+instance \c g of a directed graph type, say ListDigraph and an algorithm
 \code
 template <typename Digraph>
 …
 (in time or in memory usage) to copy \c g with the reversed
 arcs.  In this case, an adaptor class is used, which (according
 to LEMON digraph concepts) works as a digraph.  The adaptor uses the
+original digraph structure and digraph operations when methods of the
+reversed oriented graph are called.  This means that the adaptor have
 minor memory usage, and do not perform sophisticated algorithmic
+to LEMON \ref concepts::Digraph "digraph concepts") works as a digraph.
+The adaptor uses the original digraph structure and digraph operations when
+methods of the reversed oriented graph are called.  This means that the adaptor
+have minor memory usage, and do not perform sophisticated algorithmic
 actions.  The purpose of it is to give a tool for the cases when a
 graph have to be used in a specific alteration.  If this alteration is
 obtained by a usual construction like filtering the arc-set or
+obtained by a usual construction like filtering the node or the arc set or
 considering a new orientation, then an adaptor is worthwhile to use.
 To come back to the reverse oriented graph, in this situation
 …
 \code
 ListDigraph g;
 ReverseDigraph<ListGraph> rg(g);
+ReverseDigraph<ListDigraph> rg(g);
 int result = algorithm(rg);
 \endcode
 After running the algorithm, the original graph \c g is untouched.
 This techniques gives rise to an elegant code, and based on stable
+During running the algorithm, the original digraph \c g is untouched.
+This techniques give rise to an elegant code, and based on stable
 graph adaptors, complex algorithms can be implemented easily.
 In flow, circulation and bipartite matching problems, the residual
+In flow, circulation and matching problems, the residual
 graph is of particular importance. Combining an adaptor implementing
 this, shortest path algorithms and minimum mean cycle algorithms,
+this with shortest path algorithms or minimum mean cycle algorithms,
 a range of weighted and cardinality optimization algorithms can be
 obtained. For other examples, the interested user is referred to the
 …
 The behavior of graph adaptors can be very different. Some of them keep
 capabilities of the original graph while in other cases this would be
+meaningless. This means that the concepts that they are models of depend
+on the graph adaptor, and the wrapped graph(s).
+If an arc of \c rg is deleted, this is carried out by deleting the
+corresponding arc of \c g, thus the adaptor modifies the original graph.
+But for a residual graph, this operation has no sense.
+meaningless. This means that the concepts that they meet depend
+on the graph adaptor, and the wrapped graph.
+For example, if an arc of a reversed digraph is deleted, this is carried
+out by deleting the corresponding arc of the original digraph, thus the
+adaptor modifies the original digraph.
+However in case of a residual digraph, this operation has no sense.
 Let us stand one more example here to simplify your work.
 RevGraphAdaptor has constructor
+ReverseDigraph has constructor
 \code
 ReverseDigraph(Digraph& digraph);
 \endcode
 This means that in a situation, when a <tt>const ListDigraph&</tt>
+This means that in a situation, when a <tt>const %ListDigraph&</tt>
 reference to a graph is given, then it have to be instantiated with
 <tt>Digraph=const ListDigraph</tt>.
+<tt>Digraph=const %ListDigraph</tt>.
 \code
 int algorithm1(const ListDigraph& g) {
   RevGraphAdaptor<const ListDigraph> rg(g);
+  ReverseDigraph<const ListDigraph> rg(g);
   return algorithm2(rg);
+}

doc/lgf.dox

r313	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/license.dox

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/mainpage.dox

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/migration.dox

r343	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/named-param.dox

r269	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/namespaces.dox

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

doc/template.h

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/Makefile.am

-                      r468
+                      r469
 lemon_libemon_la_SOURCES = \
+        lemon/arg_parser.cc \
+        lemon/base.cc \
+        lemon/color.cc \
+        lemon/random.cc
+        lemon/arg_parser.cc \
+        lemon/base.cc \
+        lemon/color.cc \
+        lemon/lp_base.cc \
+        lemon/lp_skeleton.cc \
+        lemon/random.cc
+#lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS) $(AM_CXXFLAGS)
+#lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)
+lemon_libemon_la_CXXFLAGS = \
+        $(GLPK_CFLAGS) \
+        $(CPLEX_CFLAGS) \
+        $(SOPLEX_CXXFLAGS) \
+        $(CLP_CXXFLAGS)
+lemon_libemon_la_LDFLAGS = \
+        $(GLPK_LIBS) \
+        $(CPLEX_LIBS) \
+        $(SOPLEX_LIBS) \
+        $(CLP_LIBS)
+if HAVE_GLPK
+lemon_libemon_la_SOURCES += lemon/glpk.cc
+endif
+if HAVE_CPLEX
+lemon_libemon_la_SOURCES += lemon/cplex.cc
+endif
+if HAVE_SOPLEX
+lemon_libemon_la_SOURCES += lemon/soplex.cc
+endif
+if HAVE_CLP
+lemon_libemon_la_SOURCES += lemon/clp.cc
+endif
 lemon_HEADERS += \
         lemon/adaptors.h \
         lemon/arg_parser.h \
+        lemon/arg_parser.h \
         lemon/assert.h \
+        lemon/bfs.h \
+        lemon/bin_heap.h \
+        lemon/circulation.h \
+        lemon/color.h \
+        lemon/bfs.h \
+        lemon/bin_heap.h \
+        lemon/circulation.h \
+        lemon/clp.h \
+        lemon/color.h \
         lemon/concept_check.h \
         lemon/counter.h \
+        lemon/counter.h \
         lemon/core.h \
+        lemon/dfs.h \
+        lemon/dijkstra.h \
+        lemon/dim2.h \
+        lemon/dimacs.h \
+        lemon/cplex.h \
+        lemon/dfs.h \
+        lemon/dijkstra.h \
+        lemon/dim2.h \
+        lemon/dimacs.h \
         lemon/edge_set.h \
         lemon/elevator.h \
         lemon/error.h \
         lemon/full_graph.h \
+        lemon/graph_to_eps.h \
+        lemon/grid_graph.h \
+        lemon/glpk.h \
+        lemon/graph_to_eps.h \
+        lemon/grid_graph.h \
         lemon/hypercube_graph.h \
         lemon/kruskal.h \
 …
         lemon/lgf_reader.h \
         lemon/lgf_writer.h \
+        lemon/list_graph.h \
+        lemon/lp.h \
+        lemon/lp_base.h \
+        lemon/lp_skeleton.h \
         lemon/list_graph.h \
         lemon/maps.h \
 …
         lemon/path.h \
         lemon/preflow.h \
+        lemon/random.h \
+        lemon/radix_sort.h \
+        lemon/random.h \
         lemon/smart_graph.h \
+        lemon/soplex.h \
         lemon/suurballe.h \
         lemon/time_measure.h \
         lemon/tolerance.h \
+        lemon/time_measure.h \
+        lemon/tolerance.h \
         lemon/unionfind.h
 …
         lemon/bits/array_map.h \
         lemon/bits/base_extender.h \
         lemon/bits/bezier.h \
+        lemon/bits/bezier.h \
         lemon/bits/default_map.h \
         lemon/bits/edge_set_extender.h \
         lemon/bits/enable_if.h \
+        lemon/bits/enable_if.h \
         lemon/bits/graph_adaptor_extender.h \
         lemon/bits/graph_extender.h \
         lemon/bits/map_extender.h \
         lemon/bits/path_dump.h \
+        lemon/bits/solver_bits.h \
         lemon/bits/traits.h \
         lemon/bits/variant.h \

lemon/adaptors.h

-                      r416
+                      r464
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 /// \ingroup graph_adaptors
 /// \file
 /// \brief Several graph adaptors
+/// \brief Adaptor classes for digraphs and graphs
 ///
 /// This file contains several useful adaptors for digraphs and graphs.
 …
     int nodeNum() const { return _digraph->nodeNum(); }
     typedef EdgeNumTagIndicator<Digraph> EdgeNumTag;
+    typedef ArcNumTagIndicator<Digraph> ArcNumTag;
     int arcNum() const { return _digraph->arcNum(); }
     typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
     Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) {
+    typedef FindArcTagIndicator<Digraph> FindArcTag;
+    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const {
       return _digraph->findArc(u, v, prev);
+    }
 …
     Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); }
     void erase(const Node& n) const { _digraph->erase(n); }
     void erase(const Arc& a) const { _digraph->erase(a); }
     void clear() const { _digraph->clear(); }
+    void erase(const Node& n) { _digraph->erase(n); }
+    void erase(const Arc& a) { _digraph->erase(a); }
+    void clear() { _digraph->clear(); }
     int id(const Node& n) const { return _digraph->id(n); }
 …
     int nodeNum() const { return _graph->nodeNum(); }
+    typedef ArcNumTagIndicator<Graph> ArcNumTag;
+    int arcNum() const { return _graph->arcNum(); }
     typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
-    int arcNum() const { return _graph->arcNum(); }
     int edgeNum() const { return _graph->edgeNum(); }
+    typedef FindArcTagIndicator<Graph> FindArcTag;
+    Arc findArc(const Node& u, const Node& v,
+                const Arc& prev = INVALID) const {
+      return _graph->findArc(u, v, prev);
+    }
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
+    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) {
+      return _graph->findArc(u, v, prev);
+    }
+    Edge findEdge(const Node& u, const Node& v, const Edge& prev = INVALID) {
+    Edge findEdge(const Node& u, const Node& v,
+                  const Edge& prev = INVALID) const {
       return _graph->findEdge(u, v, prev);
+    }
 …
     Arc addArc(const Node& u, const Node& v) { return Parent::addArc(v, u); }
     typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+    typedef FindArcTagIndicator<Digraph> FindArcTag;
     Arc findArc(const Node& u, const Node& v,
                 const Arc& prev = INVALID) {
+                const Arc& prev = INVALID) const {
       return Parent::findArc(v, u, prev);
+    }
 …
   /// \ingroup graph_adaptors
   ///
+  /// \brief A digraph adaptor which reverses the orientation of the arcs.
+  ///
+  /// ReverseDigraph reverses the arcs in the adapted digraph. The
+  /// SubDigraph is conform to the \ref concepts::Digraph
+  /// "Digraph concept".
+  ///
+  /// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+  /// "Digraph concept". The type can be specified to be const.
+  template<typename _Digraph>
+  /// \brief Adaptor class for reversing the orientation of the arcs in
+  /// a digraph.
+  ///
+  /// ReverseDigraph can be used for reversing the arcs in a digraph.
+  /// It conforms to the \ref concepts::Digraph "Digraph" concept.
+  ///
+  /// The adapted digraph can also be modified through this adaptor
+  /// by adding or removing nodes or arcs, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted digraph.
+  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
+  /// It can also be specified to be \c const.
+  ///
+  /// \note The \c Node and \c Arc types of this adaptor and the adapted
+  /// digraph are convertible to each other.
+  template<typename GR>
+#ifdef DOXYGEN
+  class ReverseDigraph {
+#else
   class ReverseDigraph :
+    public DigraphAdaptorExtender<ReverseDigraphBase<_Digraph> > {
+  public:
+    typedef _Digraph Digraph;
+    typedef DigraphAdaptorExtender<
+      ReverseDigraphBase<_Digraph> > Parent;
+    public DigraphAdaptorExtender<ReverseDigraphBase<GR> > {
+#endif
+  public:
+    /// The type of the adapted digraph.
+    typedef GR Digraph;
+    typedef DigraphAdaptorExtender<ReverseDigraphBase<GR> > Parent;
   protected:
     ReverseDigraph() { }
 …
     /// \brief Constructor
     ///
     /// Creates a reverse digraph adaptor for the given digraph
+    /// Creates a reverse digraph adaptor for the given digraph.
     explicit ReverseDigraph(Digraph& digraph) {
       Parent::setDigraph(digraph);
 …
   };
+  /// \brief Just gives back a reverse digraph adaptor
+  ///
+  /// Just gives back a reverse digraph adaptor
+  template<typename Digraph>
+  ReverseDigraph<const Digraph> reverseDigraph(const Digraph& digraph) {
+    return ReverseDigraph<const Digraph>(digraph);
+  /// \brief Returns a read-only ReverseDigraph adaptor
+  ///
+  /// This function just returns a read-only \ref ReverseDigraph adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates ReverseDigraph
+  template<typename GR>
+  ReverseDigraph<const GR> reverseDigraph(const GR& digraph) {
+    return ReverseDigraph<const GR>(digraph);
+  }
   template <typename _Digraph, typename _NodeFilterMap,
 …
+    }
+    void hide(const Node& n) const { _node_filter->set(n, false); }
+    void hide(const Arc& a) const { _arc_filter->set(a, false); }
+    void unHide(const Node& n) const { _node_filter->set(n, true); }
+    void unHide(const Arc& a) const { _arc_filter->set(a, true); }
+    bool hidden(const Node& n) const { return !(*_node_filter)[n]; }
+    bool hidden(const Arc& a) const { return !(*_arc_filter)[a]; }
+    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
+    void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
+    bool status(const Node& n) const { return (*_node_filter)[n]; }
+    bool status(const Arc& a) const { return (*_arc_filter)[a]; }
     typedef False NodeNumTag;
     typedef False EdgeNumTag;
     typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+    typedef False ArcNumTag;
+    typedef FindArcTagIndicator<Digraph> FindArcTag;
     Arc findArc(const Node& source, const Node& target,
                 const Arc& prev = INVALID) {
+                const Arc& prev = INVALID) const {
       if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
         return INVALID;
 …
+    }
+    void hide(const Node& n) const { _node_filter->set(n, false); }
+    void hide(const Arc& e) const { _arc_filter->set(e, false); }
+    void unHide(const Node& n) const { _node_filter->set(n, true); }
+    void unHide(const Arc& e) const { _arc_filter->set(e, true); }
+    bool hidden(const Node& n) const { return !(*_node_filter)[n]; }
+    bool hidden(const Arc& e) const { return !(*_arc_filter)[e]; }
+    void status(const Node& n, bool v) const { _node_filter->set(n, v); }
+    void status(const Arc& a, bool v) const { _arc_filter->set(a, v); }
+    bool status(const Node& n) const { return (*_node_filter)[n]; }
+    bool status(const Arc& a) const { return (*_arc_filter)[a]; }
     typedef False NodeNumTag;
     typedef False EdgeNumTag;
     typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+    typedef False ArcNumTag;
+    typedef FindArcTagIndicator<Digraph> FindArcTag;
     Arc findArc(const Node& source, const Node& target,
                 const Arc& prev = INVALID) {
+                const Arc& prev = INVALID) const {
       if (!(*_node_filter)[source] || !(*_node_filter)[target]) {
         return INVALID;
 …
   /// \ingroup graph_adaptors
   ///
+  /// \brief An adaptor for hiding nodes and arcs in a digraph
+  ///
+  /// SubDigraph hides nodes and arcs in a digraph. A bool node map
+  /// and a bool arc map must be specified, which define the filters
+  /// for nodes and arcs. Just the nodes and arcs with true value are
+  /// shown in the subdigraph. The SubDigraph is conform to the \ref
+  /// concepts::Digraph "Digraph concept". If the \c _checked parameter
+  /// is true, then the arcs incident to filtered nodes are also
+  /// filtered out.
+  ///
+  /// \tparam _Digraph It must be conform to the \ref
+  /// concepts::Digraph "Digraph concept". The type can be specified
+  /// to const.
+  /// \tparam _NodeFilterMap A bool valued node map of the the adapted digraph.
+  /// \tparam _ArcFilterMap A bool valued arc map of the the adapted digraph.
+  /// \tparam _checked If the parameter is false then the arc filtering
+  /// is not checked with respect to node filter. Otherwise, each arc
+  /// is automatically filtered, which is incident to a filtered node.
+  /// \brief Adaptor class for hiding nodes and arcs in a digraph
+  ///
+  /// SubDigraph can be used for hiding nodes and arcs in a digraph.
+  /// A \c bool node map and a \c bool arc map must be specified, which
+  /// define the filters for nodes and arcs.
+  /// Only the nodes and arcs with \c true filter value are
+  /// shown in the subdigraph. The arcs that are incident to hidden
+  /// nodes are also filtered out.
+  /// This adaptor conforms to the \ref concepts::Digraph "Digraph" concept.
+  ///
+  /// The adapted digraph can also be modified through this adaptor
+  /// by adding or removing nodes or arcs, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted digraph.
+  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
+  /// It can also be specified to be \c const.
+  /// \tparam NF The type of the node filter map.
+  /// It must be a \c bool (or convertible) node map of the
+  /// adapted digraph. The default type is
+  /// \ref concepts::Digraph::NodeMap "GR::NodeMap<bool>".
+  /// \tparam AF The type of the arc filter map.
+  /// It must be \c bool (or convertible) arc map of the
+  /// adapted digraph. The default type is
+  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<bool>".
+  ///
+  /// \note The \c Node and \c Arc types of this adaptor and the adapted
+  /// digraph are convertible to each other.
   ///
   /// \see FilterNodes
   /// \see FilterArcs
+  template<typename _Digraph,
+           typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>,
+           typename _ArcFilterMap = typename _Digraph::template ArcMap<bool>,
+           bool _checked = true>
+  class SubDigraph
+    : public DigraphAdaptorExtender<
+      SubDigraphBase<_Digraph, _NodeFilterMap, _ArcFilterMap, _checked> > {
+  public:
+    typedef _Digraph Digraph;
+    typedef _NodeFilterMap NodeFilterMap;
+    typedef _ArcFilterMap ArcFilterMap;
+    typedef DigraphAdaptorExtender<
+      SubDigraphBase<Digraph, NodeFilterMap, ArcFilterMap, _checked> >
+    Parent;
+#ifdef DOXYGEN
+  template<typename GR, typename NF, typename AF>
+  class SubDigraph {
+#else
+  template<typename GR,
+           typename NF = typename GR::template NodeMap<bool>,
+           typename AF = typename GR::template ArcMap<bool> >
+  class SubDigraph :
+    public DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> > {
+#endif
+  public:
+    /// The type of the adapted digraph.
+    typedef GR Digraph;
+    /// The type of the node filter map.
+    typedef NF NodeFilterMap;
+    /// The type of the arc filter map.
+    typedef AF ArcFilterMap;
+    typedef DigraphAdaptorExtender<SubDigraphBase<GR, NF, AF, true> >
+      Parent;
     typedef typename Parent::Node Node;
 …
     /// \brief Constructor
     ///
     /// Creates a subdigraph for the given digraph with
     /// given node and arc map filters.
+    /// Creates a subdigraph for the given digraph with the
+    /// given node and arc filter maps.
     SubDigraph(Digraph& digraph, NodeFilterMap& node_filter,
                ArcFilterMap& arc_filter) {
 …
+    }
+    /// \brief Hides the node of the graph
+    ///
+    /// This function hides \c n in the digraph, i.e. the iteration
+    /// jumps over it. This is done by simply setting the value of \c n
+    /// to be false in the corresponding node-map.
+    void hide(const Node& n) const { Parent::hide(n); }
+    /// \brief Hides the arc of the graph
+    ///
+    /// This function hides \c a in the digraph, i.e. the iteration
+    /// jumps over it. This is done by simply setting the value of \c a
+    /// to be false in the corresponding arc-map.
+    void hide(const Arc& a) const { Parent::hide(a); }
+    /// \brief Unhides the node of the graph
+    ///
+    /// The value of \c n is set to be true in the node-map which stores
+    /// hide information. If \c n was hidden previuosly, then it is shown
+    /// again
+    void unHide(const Node& n) const { Parent::unHide(n); }
+    /// \brief Unhides the arc of the graph
+    ///
+    /// The value of \c a is set to be true in the arc-map which stores
+    /// hide information. If \c a was hidden previuosly, then it is shown
+    /// again
+    void unHide(const Arc& a) const { Parent::unHide(a); }
+    /// \brief Returns true if \c n is hidden.
+    ///
+    /// Returns true if \c n is hidden.
+    ///
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+    /// \brief Returns true if \c a is hidden.
+    ///
+    /// Returns true if \c a is hidden.
+    ///
+    bool hidden(const Arc& a) const { return Parent::hidden(a); }
+    /// \brief Sets the status of the given node
+    ///
+    /// This function sets the status of the given node.
+    /// It is done by simply setting the assigned value of \c n
+    /// to \c v in the node filter map.
+    void status(const Node& n, bool v) const { Parent::status(n, v); }
+    /// \brief Sets the status of the given arc
+    ///
+    /// This function sets the status of the given arc.
+    /// It is done by simply setting the assigned value of \c a
+    /// to \c v in the arc filter map.
+    void status(const Arc& a, bool v) const { Parent::status(a, v); }
+    /// \brief Returns the status of the given node
+    ///
+    /// This function returns the status of the given node.
+    /// It is \c true if the given node is enabled (i.e. not hidden).
+    bool status(const Node& n) const { return Parent::status(n); }
+    /// \brief Returns the status of the given arc
+    ///
+    /// This function returns the status of the given arc.
+    /// It is \c true if the given arc is enabled (i.e. not hidden).
+    bool status(const Arc& a) const { return Parent::status(a); }
+    /// \brief Disables the given node
+    ///
+    /// This function disables the given node in the subdigraph,
+    /// so the iteration jumps over it.
+    /// It is the same as \ref status() "status(n, false)".
+    void disable(const Node& n) const { Parent::status(n, false); }
+    /// \brief Disables the given arc
+    ///
+    /// This function disables the given arc in the subdigraph,
+    /// so the iteration jumps over it.
+    /// It is the same as \ref status() "status(a, false)".
+    void disable(const Arc& a) const { Parent::status(a, false); }
+    /// \brief Enables the given node
+    ///
+    /// This function enables the given node in the subdigraph.
+    /// It is the same as \ref status() "status(n, true)".
+    void enable(const Node& n) const { Parent::status(n, true); }
+    /// \brief Enables the given arc
+    ///
+    /// This function enables the given arc in the subdigraph.
+    /// It is the same as \ref status() "status(a, true)".
+    void enable(const Arc& a) const { Parent::status(a, true); }
   };
+  /// \brief Just gives back a subdigraph
+  ///
+  /// Just gives back a subdigraph
+  template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
+  SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>
+  subDigraph(const Digraph& digraph, NodeFilterMap& nfm, ArcFilterMap& afm) {
+    return SubDigraph<const Digraph, NodeFilterMap, ArcFilterMap>
+      (digraph, nfm, afm);
+  /// \brief Returns a read-only SubDigraph adaptor
+  ///
+  /// This function just returns a read-only \ref SubDigraph adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates SubDigraph
+  template<typename GR, typename NF, typename AF>
+  SubDigraph<const GR, NF, AF>
+  subDigraph(const GR& digraph,
+             NF& node_filter_map, AF& arc_filter_map) {
+    return SubDigraph<const GR, NF, AF>
+      (digraph, node_filter_map, arc_filter_map);
+  }
   template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
   SubDigraph<const Digraph, const NodeFilterMap, ArcFilterMap>
   subDigraph(const Digraph& digraph,
              const NodeFilterMap& nfm, ArcFilterMap& afm) {
     return SubDigraph<const Digraph, const NodeFilterMap, ArcFilterMap>
       (digraph, nfm, afm);
+  template<typename GR, typename NF, typename AF>
+  SubDigraph<const GR, const NF, AF>
+  subDigraph(const GR& digraph,
+             const NF& node_filter_map, AF& arc_filter_map) {
+    return SubDigraph<const GR, const NF, AF>
+      (digraph, node_filter_map, arc_filter_map);
+  }
   template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
   SubDigraph<const Digraph, NodeFilterMap, const ArcFilterMap>
   subDigraph(const Digraph& digraph,
              NodeFilterMap& nfm, const ArcFilterMap& afm) {
     return SubDigraph<const Digraph, NodeFilterMap, const ArcFilterMap>
       (digraph, nfm, afm);
+  template<typename GR, typename NF, typename AF>
+  SubDigraph<const GR, NF, const AF>
+  subDigraph(const GR& digraph,
+             NF& node_filter_map, const AF& arc_filter_map) {
+    return SubDigraph<const GR, NF, const AF>
+      (digraph, node_filter_map, arc_filter_map);
+  }
   template<typename Digraph, typename NodeFilterMap, typename ArcFilterMap>
   SubDigraph<const Digraph, const NodeFilterMap, const ArcFilterMap>
   subDigraph(const Digraph& digraph,
              const NodeFilterMap& nfm, const ArcFilterMap& afm) {
     return SubDigraph<const Digraph, const NodeFilterMap,
       const ArcFilterMap>(digraph, nfm, afm);
+  template<typename GR, typename NF, typename AF>
+  SubDigraph<const GR, const NF, const AF>
+  subDigraph(const GR& digraph,
+             const NF& node_filter_map, const AF& arc_filter_map) {
+    return SubDigraph<const GR, const NF, const AF>
+      (digraph, node_filter_map, arc_filter_map);
+  }
   template <typename _Graph, typename NodeFilterMap,
             typename EdgeFilterMap, bool _checked = true>
+  template <typename _Graph, typename _NodeFilterMap,
+            typename _EdgeFilterMap, bool _checked = true>
   class SubGraphBase : public GraphAdaptorBase<_Graph> {
   public:
     typedef _Graph Graph;
+    typedef _NodeFilterMap NodeFilterMap;
+    typedef _EdgeFilterMap EdgeFilterMap;
     typedef SubGraphBase Adaptor;
     typedef GraphAdaptorBase<_Graph> Parent;
 …
+    }
+    void hide(const Node& n) const { _node_filter_map->set(n, false); }
+    void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
+    void unHide(const Node& n) const { _node_filter_map->set(n, true); }
+    void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
+    bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
+    bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
+    void status(const Node& n, bool v) const { _node_filter_map->set(n, v); }
+    void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); }
+    bool status(const Node& n) const { return (*_node_filter_map)[n]; }
+    bool status(const Edge& e) const { return (*_edge_filter_map)[e]; }
     typedef False NodeNumTag;
+    typedef False ArcNumTag;
     typedef False EdgeNumTag;
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
+    typedef FindArcTagIndicator<Graph> FindArcTag;
     Arc findArc(const Node& u, const Node& v,
                 const Arc& prev = INVALID) {
+                const Arc& prev = INVALID) const {
       if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
         return INVALID;
 …
       return arc;
+    }
+    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
     Edge findEdge(const Node& u, const Node& v,
                   const Edge& prev = INVALID) {
+                  const Edge& prev = INVALID) const {
       if (!(*_node_filter_map)[u] || !(*_node_filter_map)[v]) {
         return INVALID;
 …
   };
   template <typename _Graph, typename NodeFilterMap, typename EdgeFilterMap>
   class SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap, false>
+  template <typename _Graph, typename _NodeFilterMap, typename _EdgeFilterMap>
+  class SubGraphBase<_Graph, _NodeFilterMap, _EdgeFilterMap, false>
     : public GraphAdaptorBase<_Graph> {
   public:
     typedef _Graph Graph;
+    typedef _NodeFilterMap NodeFilterMap;
+    typedef _EdgeFilterMap EdgeFilterMap;
     typedef SubGraphBase Adaptor;
     typedef GraphAdaptorBase<_Graph> Parent;
 …
+    }
+    void hide(const Node& n) const { _node_filter_map->set(n, false); }
+    void hide(const Edge& e) const { _edge_filter_map->set(e, false); }
+    void unHide(const Node& n) const { _node_filter_map->set(n, true); }
+    void unHide(const Edge& e) const { _edge_filter_map->set(e, true); }
+    bool hidden(const Node& n) const { return !(*_node_filter_map)[n]; }
+    bool hidden(const Edge& e) const { return !(*_edge_filter_map)[e]; }
+    void status(const Node& n, bool v) const { _node_filter_map->set(n, v); }
+    void status(const Edge& e, bool v) const { _edge_filter_map->set(e, v); }
+    bool status(const Node& n) const { return (*_node_filter_map)[n]; }
+    bool status(const Edge& e) const { return (*_edge_filter_map)[e]; }
     typedef False NodeNumTag;
+    typedef False ArcNumTag;
     typedef False EdgeNumTag;
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
+    typedef FindArcTagIndicator<Graph> FindArcTag;
     Arc findArc(const Node& u, const Node& v,
                 const Arc& prev = INVALID) {
+                const Arc& prev = INVALID) const {
       Arc arc = Parent::findArc(u, v, prev);
       while (arc != INVALID && !(*_edge_filter_map)[arc]) {
 …
       return arc;
+    }
+    typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
     Edge findEdge(const Node& u, const Node& v,
                   const Edge& prev = INVALID) {
+                  const Edge& prev = INVALID) const {
       Edge edge = Parent::findEdge(u, v, prev);
       while (edge != INVALID && !(*_edge_filter_map)[edge]) {
 …
   /// \ingroup graph_adaptors
   ///
+  /// \brief A graph adaptor for hiding nodes and edges in an
+  /// undirected graph.
+  ///
+  /// SubGraph hides nodes and edges in a graph. A bool node map and a
+  /// bool edge map must be specified, which define the filters for
+  /// nodes and edges. Just the nodes and edges with true value are
+  /// shown in the subgraph. The SubGraph is conform to the \ref
+  /// concepts::Graph "Graph concept". If the \c _checked parameter is
+  /// true, then the edges incident to filtered nodes are also
+  /// filtered out.
+  ///
+  /// \tparam _Graph It must be conform to the \ref
+  /// concepts::Graph "Graph concept". The type can be specified
+  /// to const.
+  /// \tparam _NodeFilterMap A bool valued node map of the the adapted graph.
+  /// \tparam _EdgeFilterMap A bool valued edge map of the the adapted graph.
+  /// \tparam _checked If the parameter is false then the edge filtering
+  /// is not checked with respect to node filter. Otherwise, each edge
+  /// is automatically filtered, which is incident to a filtered node.
+  /// \brief Adaptor class for hiding nodes and edges in an undirected
+  /// graph.
+  ///
+  /// SubGraph can be used for hiding nodes and edges in a graph.
+  /// A \c bool node map and a \c bool edge map must be specified, which
+  /// define the filters for nodes and edges.
+  /// Only the nodes and edges with \c true filter value are
+  /// shown in the subgraph. The edges that are incident to hidden
+  /// nodes are also filtered out.
+  /// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
+  ///
+  /// The adapted graph can also be modified through this adaptor
+  /// by adding or removing nodes or edges, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted graph.
+  /// It must conform to the \ref concepts::Graph "Graph" concept.
+  /// It can also be specified to be \c const.
+  /// \tparam NF The type of the node filter map.
+  /// It must be a \c bool (or convertible) node map of the
+  /// adapted graph. The default type is
+  /// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
+  /// \tparam EF The type of the edge filter map.
+  /// It must be a \c bool (or convertible) edge map of the
+  /// adapted graph. The default type is
+  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
+  ///
+  /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
+  /// adapted graph are convertible to each other.
   ///
   /// \see FilterNodes
   /// \see FilterEdges
+  template<typename _Graph, typename NodeFilterMap,
+           typename EdgeFilterMap, bool _checked = true>
+  class SubGraph
+    : public GraphAdaptorExtender<
+      SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap, _checked> > {
+  public:
+    typedef _Graph Graph;
+    typedef GraphAdaptorExtender<
+      SubGraphBase<_Graph, NodeFilterMap, EdgeFilterMap> > Parent;
+#ifdef DOXYGEN
+  template<typename GR, typename NF, typename EF>
+  class SubGraph {
+#else
+  template<typename GR,
+           typename NF = typename GR::template NodeMap<bool>,
+           typename EF = typename GR::template EdgeMap<bool> >
+  class SubGraph :
+    public GraphAdaptorExtender<SubGraphBase<GR, NF, EF, true> > {
+#endif
+  public:
+    /// The type of the adapted graph.
+    typedef GR Graph;
+    /// The type of the node filter map.
+    typedef NF NodeFilterMap;
+    /// The type of the edge filter map.
+    typedef EF EdgeFilterMap;
+    typedef GraphAdaptorExtender< SubGraphBase<GR, NF, EF, true> >
+      Parent;
     typedef typename Parent::Node Node;
 …
     /// \brief Constructor
     ///
     /// Creates a subgraph for the given graph with given node and
     /// edge map filters.
     SubGraph(Graph& _graph, NodeFilterMap& node_filter_map,
+    /// Creates a subgraph for the given graph with the given node
+    /// and edge filter maps.
+    SubGraph(Graph& graph, NodeFilterMap& node_filter_map,
              EdgeFilterMap& edge_filter_map) {
       setGraph(_graph);
+      setGraph(graph);
       setNodeFilterMap(node_filter_map);
       setEdgeFilterMap(edge_filter_map);
+    }
+    /// \brief Hides the node of the graph
+    ///
+    /// This function hides \c n in the graph, i.e. the iteration
+    /// jumps over it. This is done by simply setting the value of \c n
+    /// to be false in the corresponding node-map.
+    void hide(const Node& n) const { Parent::hide(n); }
+    /// \brief Hides the edge of the graph
+    ///
+    /// This function hides \c e in the graph, i.e. the iteration
+    /// jumps over it. This is done by simply setting the value of \c e
+    /// to be false in the corresponding edge-map.
+    void hide(const Edge& e) const { Parent::hide(e); }
+    /// \brief Unhides the node of the graph
+    ///
+    /// The value of \c n is set to be true in the node-map which stores
+    /// hide information. If \c n was hidden previuosly, then it is shown
+    /// again
+    void unHide(const Node& n) const { Parent::unHide(n); }
+    /// \brief Unhides the edge of the graph
+    ///
+    /// The value of \c e is set to be true in the edge-map which stores
+    /// hide information. If \c e was hidden previuosly, then it is shown
+    /// again
+    void unHide(const Edge& e) const { Parent::unHide(e); }
+    /// \brief Returns true if \c n is hidden.
+    ///
+    /// Returns true if \c n is hidden.
+    ///
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+    /// \brief Returns true if \c e is hidden.
+    ///
+    /// Returns true if \c e is hidden.
+    ///
+    bool hidden(const Edge& e) const { return Parent::hidden(e); }
+    /// \brief Sets the status of the given node
+    ///
+    /// This function sets the status of the given node.
+    /// It is done by simply setting the assigned value of \c n
+    /// to \c v in the node filter map.
+    void status(const Node& n, bool v) const { Parent::status(n, v); }
+    /// \brief Sets the status of the given edge
+    ///
+    /// This function sets the status of the given edge.
+    /// It is done by simply setting the assigned value of \c e
+    /// to \c v in the edge filter map.
+    void status(const Edge& e, bool v) const { Parent::status(e, v); }
+    /// \brief Returns the status of the given node
+    ///
+    /// This function returns the status of the given node.
+    /// It is \c true if the given node is enabled (i.e. not hidden).
+    bool status(const Node& n) const { return Parent::status(n); }
+    /// \brief Returns the status of the given edge
+    ///
+    /// This function returns the status of the given edge.
+    /// It is \c true if the given edge is enabled (i.e. not hidden).
+    bool status(const Edge& e) const { return Parent::status(e); }
+    /// \brief Disables the given node
+    ///
+    /// This function disables the given node in the subdigraph,
+    /// so the iteration jumps over it.
+    /// It is the same as \ref status() "status(n, false)".
+    void disable(const Node& n) const { Parent::status(n, false); }
+    /// \brief Disables the given edge
+    ///
+    /// This function disables the given edge in the subgraph,
+    /// so the iteration jumps over it.
+    /// It is the same as \ref status() "status(e, false)".
+    void disable(const Edge& e) const { Parent::status(e, false); }
+    /// \brief Enables the given node
+    ///
+    /// This function enables the given node in the subdigraph.
+    /// It is the same as \ref status() "status(n, true)".
+    void enable(const Node& n) const { Parent::status(n, true); }
+    /// \brief Enables the given edge
+    ///
+    /// This function enables the given edge in the subgraph.
+    /// It is the same as \ref status() "status(e, true)".
+    void enable(const Edge& e) const { Parent::status(e, true); }
   };
+  /// \brief Just gives back a subgraph
+  ///
+  /// Just gives back a subgraph
+  template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
+  SubGraph<const Graph, NodeFilterMap, ArcFilterMap>
+  subGraph(const Graph& graph, NodeFilterMap& nfm, ArcFilterMap& efm) {
+    return SubGraph<const Graph, NodeFilterMap, ArcFilterMap>(graph, nfm, efm);
+  /// \brief Returns a read-only SubGraph adaptor
+  ///
+  /// This function just returns a read-only \ref SubGraph adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates SubGraph
+  template<typename GR, typename NF, typename EF>
+  SubGraph<const GR, NF, EF>
+  subGraph(const GR& graph,
+           NF& node_filter_map, EF& edge_filter_map) {
+    return SubGraph<const GR, NF, EF>
+      (graph, node_filter_map, edge_filter_map);
+  }
   template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
   SubGraph<const Graph, const NodeFilterMap, ArcFilterMap>
   subGraph(const Graph& graph,
            const NodeFilterMap& nfm, ArcFilterMap& efm) {
     return SubGraph<const Graph, const NodeFilterMap, ArcFilterMap>
       (graph, nfm, efm);
+  template<typename GR, typename NF, typename EF>
+  SubGraph<const GR, const NF, EF>
+  subGraph(const GR& graph,
+           const NF& node_filter_map, EF& edge_filter_map) {
+    return SubGraph<const GR, const NF, EF>
+      (graph, node_filter_map, edge_filter_map);
+  }
   template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
   SubGraph<const Graph, NodeFilterMap, const ArcFilterMap>
   subGraph(const Graph& graph,
            NodeFilterMap& nfm, const ArcFilterMap& efm) {
     return SubGraph<const Graph, NodeFilterMap, const ArcFilterMap>
       (graph, nfm, efm);
+  template<typename GR, typename NF, typename EF>
+  SubGraph<const GR, NF, const EF>
+  subGraph(const GR& graph,
+           NF& node_filter_map, const EF& edge_filter_map) {
+    return SubGraph<const GR, NF, const EF>
+      (graph, node_filter_map, edge_filter_map);
+  }
   template<typename Graph, typename NodeFilterMap, typename ArcFilterMap>
   SubGraph<const Graph, const NodeFilterMap, const ArcFilterMap>
   subGraph(const Graph& graph,
            const NodeFilterMap& nfm, const ArcFilterMap& efm) {
     return SubGraph<const Graph, const NodeFilterMap, const ArcFilterMap>
       (graph, nfm, efm);
+  template<typename GR, typename NF, typename EF>
+  SubGraph<const GR, const NF, const EF>
+  subGraph(const GR& graph,
+           const NF& node_filter_map, const EF& edge_filter_map) {
+    return SubGraph<const GR, const NF, const EF>
+      (graph, node_filter_map, edge_filter_map);
+  }
   /// \ingroup graph_adaptors
   ///
+  /// \brief An adaptor for hiding nodes from a digraph or a graph.
+  ///
+  /// FilterNodes adaptor hides nodes in a graph or a digraph. A bool
+  /// node map must be specified, which defines the filters for
+  /// nodes. Just the unfiltered nodes and the arcs or edges incident
+  /// to unfiltered nodes are shown in the subdigraph or subgraph. The
+  /// FilterNodes is conform to the \ref concepts::Digraph
+  /// "Digraph concept" or \ref concepts::Graph "Graph concept" depending
+  /// on the \c _Digraph template parameter. If the \c _checked
+  /// parameter is true, then the arc or edges incident to filtered nodes
+  /// are also filtered out.
+  ///
+  /// \tparam _Digraph It must be conform to the \ref
+  /// concepts::Digraph "Digraph concept" or \ref concepts::Graph
+  /// "Graph concept". The type can be specified to be const.
+  /// \tparam _NodeFilterMap A bool valued node map of the the adapted graph.
+  /// \tparam _checked If the parameter is false then the arc or edge
+  /// filtering is not checked with respect to node filter. In this
+  /// case just isolated nodes can be filtered out from the
+  /// graph.
+  /// \brief Adaptor class for hiding nodes in a digraph or a graph.
+  ///
+  /// FilterNodes adaptor can be used for hiding nodes in a digraph or a
+  /// graph. A \c bool node map must be specified, which defines the filter
+  /// for the nodes. Only the nodes with \c true filter value and the
+  /// arcs/edges incident to nodes both with \c true filter value are shown
+  /// in the subgraph. This adaptor conforms to the \ref concepts::Digraph
+  /// "Digraph" concept or the \ref concepts::Graph "Graph" concept
+  /// depending on the \c GR template parameter.
+  ///
+  /// The adapted (di)graph can also be modified through this adaptor
+  /// by adding or removing nodes or arcs/edges, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted digraph or graph.
+  /// It must conform to the \ref concepts::Digraph "Digraph" concept
+  /// or the \ref concepts::Graph "Graph" concept.
+  /// It can also be specified to be \c const.
+  /// \tparam NF The type of the node filter map.
+  /// It must be a \c bool (or convertible) node map of the
+  /// adapted (di)graph. The default type is
+  /// \ref concepts::Graph::NodeMap "GR::NodeMap<bool>".
+  ///
+  /// \note The \c Node and <tt>Arc/Edge</tt> types of this adaptor and the
+  /// adapted (di)graph are convertible to each other.
 #ifdef DOXYGEN
+  template<typename _Digraph,
+           typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>,
+           bool _checked = true>
+  template<typename GR, typename NF>
+  class FilterNodes {
 #else
+  template<typename _Digraph,
+           typename _NodeFilterMap = typename _Digraph::template NodeMap<bool>,
+           bool _checked = true,
+  template<typename GR,
+           typename NF = typename GR::template NodeMap<bool>,
            typename Enable = void>
+  class FilterNodes :
+    public DigraphAdaptorExtender<
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, bool>, true> > {
 #endif
+  class FilterNodes
+    : public SubDigraph<_Digraph, _NodeFilterMap,
+                        ConstMap<typename _Digraph::Arc, bool>, _checked> {
+  public:
+    typedef _Digraph Digraph;
+    typedef _NodeFilterMap NodeFilterMap;
+    typedef SubDigraph<Digraph, NodeFilterMap,
+                       ConstMap<typename Digraph::Arc, bool>, _checked>
+    Parent;
+  public:
+    typedef GR Digraph;
+    typedef NF NodeFilterMap;
+    typedef DigraphAdaptorExtender<
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, bool>, true> >
+      Parent;
     typedef typename Parent::Node Node;
 …
     /// \brief Constructor
     ///
     /// Creates an adaptor for the given digraph or graph with
+    /// Creates a subgraph for the given digraph or graph with the
     /// given node filter map.
+    FilterNodes(Digraph& _digraph, NodeFilterMap& node_filter) :
+      Parent(), const_true_map(true) {
+      Parent::setDigraph(_digraph);
+    FilterNodes(GR& graph, NodeFilterMap& node_filter) :
+      Parent(), const_true_map(true)
+    {
+      Parent::setDigraph(graph);
       Parent::setNodeFilterMap(node_filter);
       Parent::setArcFilterMap(const_true_map);
+    }
+    /// \brief Hides the node of the graph
+    ///
+    /// This function hides \c n in the digraph or graph, i.e. the iteration
+    /// jumps over it. This is done by simply setting the value of \c n
+    /// to be false in the corresponding node map.
+    void hide(const Node& n) const { Parent::hide(n); }
+    /// \brief Unhides the node of the graph
+    ///
+    /// The value of \c n is set to be true in the node-map which stores
+    /// hide information. If \c n was hidden previuosly, then it is shown
+    /// again
+    void unHide(const Node& n) const { Parent::unHide(n); }
+    /// \brief Returns true if \c n is hidden.
+    ///
+    /// Returns true if \c n is hidden.
+    ///
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+    /// \brief Sets the status of the given node
+    ///
+    /// This function sets the status of the given node.
+    /// It is done by simply setting the assigned value of \c n
+    /// to \c v in the node filter map.
+    void status(const Node& n, bool v) const { Parent::status(n, v); }
+    /// \brief Returns the status of the given node
+    ///
+    /// This function returns the status of the given node.
+    /// It is \c true if the given node is enabled (i.e. not hidden).
+    bool status(const Node& n) const { return Parent::status(n); }
+    /// \brief Disables the given node
+    ///
+    /// This function disables the given node, so the iteration
+    /// jumps over it.
+    /// It is the same as \ref status() "status(n, false)".
+    void disable(const Node& n) const { Parent::status(n, false); }
+    /// \brief Enables the given node
+    ///
+    /// This function enables the given node.
+    /// It is the same as \ref status() "status(n, true)".
+    void enable(const Node& n) const { Parent::status(n, true); }
   };
+  template<typename _Graph, typename _NodeFilterMap, bool _checked>
+  class FilterNodes<_Graph, _NodeFilterMap, _checked,
+                    typename enable_if<UndirectedTagIndicator<_Graph> >::type>
+    : public SubGraph<_Graph, _NodeFilterMap,
+                      ConstMap<typename _Graph::Edge, bool>, _checked> {
+  public:
+    typedef _Graph Graph;
+    typedef _NodeFilterMap NodeFilterMap;
+    typedef SubGraph<Graph, NodeFilterMap,
+                     ConstMap<typename Graph::Edge, bool> > Parent;
+  template<typename GR, typename NF>
+  class FilterNodes<GR, NF,
+                    typename enable_if<UndirectedTagIndicator<GR> >::type> :
+    public GraphAdaptorExtender<
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, bool>, true> > {
+  public:
+    typedef GR Graph;
+    typedef NF NodeFilterMap;
+    typedef GraphAdaptorExtender<
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, bool>, true> >
+      Parent;
     typedef typename Parent::Node Node;
 …
+    }
+    void hide(const Node& n) const { Parent::hide(n); }
+    void unHide(const Node& n) const { Parent::unHide(n); }
+    bool hidden(const Node& n) const { return Parent::hidden(n); }
+    void status(const Node& n, bool v) const { Parent::status(n, v); }
+    bool status(const Node& n) const { return Parent::status(n); }
+    void disable(const Node& n) const { Parent::status(n, false); }
+    void enable(const Node& n) const { Parent::status(n, true); }
   };
+  /// \brief Just gives back a FilterNodes adaptor
+  ///
+  /// Just gives back a FilterNodes adaptor
+  template<typename Digraph, typename NodeFilterMap>
+  FilterNodes<const Digraph, NodeFilterMap>
+  filterNodes(const Digraph& digraph, NodeFilterMap& nfm) {
+    return FilterNodes<const Digraph, NodeFilterMap>(digraph, nfm);
+  /// \brief Returns a read-only FilterNodes adaptor
+  ///
+  /// This function just returns a read-only \ref FilterNodes adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates FilterNodes
+  template<typename GR, typename NF>
+  FilterNodes<const GR, NF>
+  filterNodes(const GR& graph, NF& node_filter_map) {
+    return FilterNodes<const GR, NF>(graph, node_filter_map);
+  }
   template<typename Digraph, typename NodeFilterMap>
   FilterNodes<const Digraph, const NodeFilterMap>
   filterNodes(const Digraph& digraph, const NodeFilterMap& nfm) {
     return FilterNodes<const Digraph, const NodeFilterMap>(digraph, nfm);
+  template<typename GR, typename NF>
+  FilterNodes<const GR, const NF>
+  filterNodes(const GR& graph, const NF& node_filter_map) {
+    return FilterNodes<const GR, const NF>(graph, node_filter_map);
+  }
   /// \ingroup graph_adaptors
   ///
+  /// \brief An adaptor for hiding arcs from a digraph.
+  ///
+  /// FilterArcs adaptor hides arcs in a digraph. A bool arc map must
+  /// be specified, which defines the filters for arcs. Just the
+  /// unfiltered arcs are shown in the subdigraph. The FilterArcs is
+  /// conform to the \ref concepts::Digraph "Digraph concept".
+  ///
+  /// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+  /// "Digraph concept". The type can be specified to be const.
+  /// \tparam _ArcFilterMap A bool valued arc map of the the adapted
+  /// graph.
+  template<typename _Digraph, typename _ArcFilterMap>
+  /// \brief Adaptor class for hiding arcs in a digraph.
+  ///
+  /// FilterArcs adaptor can be used for hiding arcs in a digraph.
+  /// A \c bool arc map must be specified, which defines the filter for
+  /// the arcs. Only the arcs with \c true filter value are shown in the
+  /// subdigraph. This adaptor conforms to the \ref concepts::Digraph
+  /// "Digraph" concept.
+  ///
+  /// The adapted digraph can also be modified through this adaptor
+  /// by adding or removing nodes or arcs, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted digraph.
+  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
+  /// It can also be specified to be \c const.
+  /// \tparam AF The type of the arc filter map.
+  /// It must be a \c bool (or convertible) arc map of the
+  /// adapted digraph. The default type is
+  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<bool>".
+  ///
+  /// \note The \c Node and \c Arc types of this adaptor and the adapted
+  /// digraph are convertible to each other.
+#ifdef DOXYGEN
+  template<typename GR,
+           typename AF>
+  class FilterArcs {
+#else
+  template<typename GR,
+           typename AF = typename GR::template ArcMap<bool> >
   class FilterArcs :
+    public SubDigraph<_Digraph, ConstMap<typename _Digraph::Node, bool>,
+                      _ArcFilterMap, false> {
+  public:
+    typedef _Digraph Digraph;
+    typedef _ArcFilterMap ArcFilterMap;
+    typedef SubDigraph<Digraph, ConstMap<typename Digraph::Node, bool>,
+                       ArcFilterMap, false> Parent;
+    public DigraphAdaptorExtender<
+      SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> > {
+#endif
+  public:
+    /// The type of the adapted digraph.
+    typedef GR Digraph;
+    /// The type of the arc filter map.
+    typedef AF ArcFilterMap;
+    typedef DigraphAdaptorExtender<
+      SubDigraphBase<GR, ConstMap<typename GR::Node, bool>, AF, false> >
+      Parent;
     typedef typename Parent::Arc Arc;
 …
     /// \brief Constructor
     ///
     /// Creates a FilterArcs adaptor for the given graph with
     /// given arc map filter.
+    /// Creates a subdigraph for the given digraph with the given arc
+    /// filter map.
     FilterArcs(Digraph& digraph, ArcFilterMap& arc_filter)
       : Parent(), const_true_map(true) {
 …
+    }
+    /// \brief Hides the arc of the graph
+    ///
+    /// This function hides \c a in the graph, i.e. the iteration
+    /// jumps over it. This is done by simply setting the value of \c a
+    /// to be false in the corresponding arc map.
+    void hide(const Arc& a) const { Parent::hide(a); }
+    /// \brief Unhides the arc of the graph
+    ///
+    /// The value of \c a is set to be true in the arc-map which stores
+    /// hide information. If \c a was hidden previuosly, then it is shown
+    /// again
+    void unHide(const Arc& a) const { Parent::unHide(a); }
+    /// \brief Returns true if \c a is hidden.
+    ///
+    /// Returns true if \c a is hidden.
+    ///
+    bool hidden(const Arc& a) const { return Parent::hidden(a); }
+    /// \brief Sets the status of the given arc
+    ///
+    /// This function sets the status of the given arc.
+    /// It is done by simply setting the assigned value of \c a
+    /// to \c v in the arc filter map.
+    void status(const Arc& a, bool v) const { Parent::status(a, v); }
+    /// \brief Returns the status of the given arc
+    ///
+    /// This function returns the status of the given arc.
+    /// It is \c true if the given arc is enabled (i.e. not hidden).
+    bool status(const Arc& a) const { return Parent::status(a); }
+    /// \brief Disables the given arc
+    ///
+    /// This function disables the given arc in the subdigraph,
+    /// so the iteration jumps over it.
+    /// It is the same as \ref status() "status(a, false)".
+    void disable(const Arc& a) const { Parent::status(a, false); }
+    /// \brief Enables the given arc
+    ///
+    /// This function enables the given arc in the subdigraph.
+    /// It is the same as \ref status() "status(a, true)".
+    void enable(const Arc& a) const { Parent::status(a, true); }
   };
+  /// \brief Just gives back an FilterArcs adaptor
+  ///
+  /// Just gives back an FilterArcs adaptor
+  template<typename Digraph, typename ArcFilterMap>
+  FilterArcs<const Digraph, ArcFilterMap>
+  filterArcs(const Digraph& digraph, ArcFilterMap& afm) {
+    return FilterArcs<const Digraph, ArcFilterMap>(digraph, afm);
+  /// \brief Returns a read-only FilterArcs adaptor
+  ///
+  /// This function just returns a read-only \ref FilterArcs adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates FilterArcs
+  template<typename GR, typename AF>
+  FilterArcs<const GR, AF>
+  filterArcs(const GR& digraph, AF& arc_filter_map) {
+    return FilterArcs<const GR, AF>(digraph, arc_filter_map);
+  }
   template<typename Digraph, typename ArcFilterMap>
   FilterArcs<const Digraph, const ArcFilterMap>
   filterArcs(const Digraph& digraph, const ArcFilterMap& afm) {
     return FilterArcs<const Digraph, const ArcFilterMap>(digraph, afm);
+  template<typename GR, typename AF>
+  FilterArcs<const GR, const AF>
+  filterArcs(const GR& digraph, const AF& arc_filter_map) {
+    return FilterArcs<const GR, const AF>(digraph, arc_filter_map);
+  }
   /// \ingroup graph_adaptors
   ///
+  /// \brief An adaptor for hiding edges from a graph.
+  ///
+  /// FilterEdges adaptor hides edges in a digraph. A bool edge map must
+  /// be specified, which defines the filters for edges. Just the
+  /// unfiltered edges are shown in the subdigraph. The FilterEdges is
+  /// conform to the \ref concepts::Graph "Graph concept".
+  ///
+  /// \tparam _Graph It must be conform to the \ref concepts::Graph
+  /// "Graph concept". The type can be specified to be const.
+  /// \tparam _EdgeFilterMap A bool valued edge map of the the adapted
+  /// graph.
+  template<typename _Graph, typename _EdgeFilterMap>
+  /// \brief Adaptor class for hiding edges in a graph.
+  ///
+  /// FilterEdges adaptor can be used for hiding edges in a graph.
+  /// A \c bool edge map must be specified, which defines the filter for
+  /// the edges. Only the edges with \c true filter value are shown in the
+  /// subgraph. This adaptor conforms to the \ref concepts::Graph
+  /// "Graph" concept.
+  ///
+  /// The adapted graph can also be modified through this adaptor
+  /// by adding or removing nodes or edges, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted graph.
+  /// It must conform to the \ref concepts::Graph "Graph" concept.
+  /// It can also be specified to be \c const.
+  /// \tparam EF The type of the edge filter map.
+  /// It must be a \c bool (or convertible) edge map of the
+  /// adapted graph. The default type is
+  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
+  ///
+  /// \note The \c Node, \c Edge and \c Arc types of this adaptor and the
+  /// adapted graph are convertible to each other.
+#ifdef DOXYGEN
+  template<typename GR,
+           typename EF>
+  class FilterEdges {
+#else
+  template<typename GR,
+           typename EF = typename GR::template EdgeMap<bool> >
   class FilterEdges :
+    public SubGraph<_Graph, ConstMap<typename _Graph::Node,bool>,
+                    _EdgeFilterMap, false> {
+  public:
+    typedef _Graph Graph;
+    typedef _EdgeFilterMap EdgeFilterMap;
+    typedef SubGraph<Graph, ConstMap<typename Graph::Node,bool>,
+                     EdgeFilterMap, false> Parent;
+    public GraphAdaptorExtender<
+      SubGraphBase<GR, ConstMap<typename GR::Node,bool>, EF, false> > {
+#endif
+  public:
+    /// The type of the adapted graph.
+    typedef GR Graph;
+    /// The type of the edge filter map.
+    typedef EF EdgeFilterMap;
+    typedef GraphAdaptorExtender<
+      SubGraphBase<GR, ConstMap<typename GR::Node,bool>, EF, false> >
+      Parent;
     typedef typename Parent::Edge Edge;
   protected:
     ConstMap<typename Graph::Node, bool> const_true_map;
 …
     /// \brief Constructor
     ///
     /// Creates a FilterEdges adaptor for the given graph with
     /// given edge map filters.
     FilterEdges(Graph& _graph, EdgeFilterMap& edge_filter_map) :
+    /// Creates a subgraph for the given graph with the given edge
+    /// filter map.
+    FilterEdges(Graph& graph, EdgeFilterMap& edge_filter_map) :
       Parent(), const_true_map(true) {
       Parent::setGraph(_graph);
+      Parent::setGraph(graph);
       Parent::setNodeFilterMap(const_true_map);
       Parent::setEdgeFilterMap(edge_filter_map);
+    }
+    /// \brief Hides the edge of the graph
+    ///
+    /// This function hides \c e in the graph, i.e. the iteration
+    /// jumps over it. This is done by simply setting the value of \c e
+    /// to be false in the corresponding edge-map.
+    void hide(const Edge& e) const { Parent::hide(e); }
+    /// \brief Unhides the edge of the graph
+    ///
+    /// The value of \c e is set to be true in the edge-map which stores
+    /// hide information. If \c e was hidden previuosly, then it is shown
+    /// again
+    void unHide(const Edge& e) const { Parent::unHide(e); }
+    /// \brief Returns true if \c e is hidden.
+    ///
+    /// Returns true if \c e is hidden.
+    ///
+    bool hidden(const Edge& e) const { return Parent::hidden(e); }
+    /// \brief Sets the status of the given edge
+    ///
+    /// This function sets the status of the given edge.
+    /// It is done by simply setting the assigned value of \c e
+    /// to \c v in the edge filter map.
+    void status(const Edge& e, bool v) const { Parent::status(e, v); }
+    /// \brief Returns the status of the given edge
+    ///
+    /// This function returns the status of the given edge.
+    /// It is \c true if the given edge is enabled (i.e. not hidden).
+    bool status(const Edge& e) const { return Parent::status(e); }
+    /// \brief Disables the given edge
+    ///
+    /// This function disables the given edge in the subgraph,
+    /// so the iteration jumps over it.
+    /// It is the same as \ref status() "status(e, false)".
+    void disable(const Edge& e) const { Parent::status(e, false); }
+    /// \brief Enables the given edge
+    ///
+    /// This function enables the given edge in the subgraph.
+    /// It is the same as \ref status() "status(e, true)".
+    void enable(const Edge& e) const { Parent::status(e, true); }
   };
+  /// \brief Just gives back a FilterEdges adaptor
+  ///
+  /// Just gives back a FilterEdges adaptor
+  template<typename Graph, typename EdgeFilterMap>
+  FilterEdges<const Graph, EdgeFilterMap>
+  filterEdges(const Graph& graph, EdgeFilterMap& efm) {
+    return FilterEdges<const Graph, EdgeFilterMap>(graph, efm);
+  /// \brief Returns a read-only FilterEdges adaptor
+  ///
+  /// This function just returns a read-only \ref FilterEdges adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates FilterEdges
+  template<typename GR, typename EF>
+  FilterEdges<const GR, EF>
+  filterEdges(const GR& graph, EF& edge_filter_map) {
+    return FilterEdges<const GR, EF>(graph, edge_filter_map);
+  }
   template<typename Graph, typename EdgeFilterMap>
   FilterEdges<const Graph, const EdgeFilterMap>
   filterEdges(const Graph& graph, const EdgeFilterMap& efm) {
     return FilterEdges<const Graph, const EdgeFilterMap>(graph, efm);
+  template<typename GR, typename EF>
+  FilterEdges<const GR, const EF>
+  filterEdges(const GR& graph, const EF& edge_filter_map) {
+    return FilterEdges<const GR, const EF>(graph, edge_filter_map);
+  }
   template <typename _Digraph>
 …
+      }
     };
     void first(Node& n) const {
 …
     typedef NodeNumTagIndicator<Digraph> NodeNumTag;
+    int nodeNum() const { return 2 * _digraph->arcNum(); }
+    typedef EdgeNumTagIndicator<Digraph> EdgeNumTag;
+    int nodeNum() const { return _digraph->nodeNum(); }
+    typedef ArcNumTagIndicator<Digraph> ArcNumTag;
     int arcNum() const { return 2 * _digraph->arcNum(); }
+    typedef ArcNumTag EdgeNumTag;
     int edgeNum() const { return _digraph->arcNum(); }
     typedef FindEdgeTagIndicator<Digraph> FindEdgeTag;
+    typedef FindArcTagIndicator<Digraph> FindArcTag;
     Arc findArc(Node s, Node t, Arc p = INVALID) const {
       if (p == INVALID) {
 …
+    }
+    typedef FindArcTag FindEdgeTag;
     Edge findEdge(Node s, Node t, Edge p = INVALID) const {
       if (s != t) {
 …
           arc = _digraph->findArc(t, s);
           if (arc != INVALID) return arc;
         } else if (_digraph->s(p) == s) {
+        } else if (_digraph->source(p) == s) {
           Edge arc = _digraph->findArc(s, t, p);
           if (arc != INVALID) return arc;
 …
       typedef _Value Value;
       typedef Arc Key;
+      typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<MapImpl>::ReturnValue ReturnValue;
+      typedef typename MapTraits<MapImpl>::ConstReturnValue ConstReference;
+      typedef typename MapTraits<MapImpl>::ReturnValue Reference;
       ArcMapBase(const Adaptor& adaptor) :
 …
+      }
+      typename MapTraits<MapImpl>::ConstReturnValue
+      operator[](const Arc& a) const {
+      ConstReturnValue operator[](const Arc& a) const {
         if (direction(a)) {
           return _forward[a];
 …
+      }
+      typename MapTraits<MapImpl>::ReturnValue
+      operator[](const Arc& a) {
+      ReturnValue operator[](const Arc& a) {
         if (direction(a)) {
           return _forward[a];
 …
       typedef SubMapExtender<Adaptor, ArcMapBase<Value> > Parent;
       ArcMap(const Adaptor& adaptor)
+      explicit ArcMap(const Adaptor& adaptor)
         : Parent(adaptor) {}
 …
     NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }
+    typedef typename ItemSetTraits<Digraph, Edge>::ItemNotifier EdgeNotifier;
+    EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
   protected:
 …
   /// \ingroup graph_adaptors
   ///
+  /// \brief Undirect the graph
+  ///
+  /// This adaptor makes an undirected graph from a directed
+  /// graph. All arcs of the underlying digraph will be showed in the
+  /// adaptor as an edge. The Orienter adaptor is conform to the \ref
+  /// concepts::Graph "Graph concept".
+  ///
+  /// \tparam _Digraph It must be conform to the \ref
+  /// concepts::Digraph "Digraph concept". The type can be specified
+  /// to const.
+  template<typename _Digraph>
+  class Undirector
+    : public GraphAdaptorExtender<UndirectorBase<_Digraph> > {
+  public:
+    typedef _Digraph Digraph;
+    typedef GraphAdaptorExtender<UndirectorBase<Digraph> > Parent;
+  /// \brief Adaptor class for viewing a digraph as an undirected graph.
+  ///
+  /// Undirector adaptor can be used for viewing a digraph as an undirected
+  /// graph. All arcs of the underlying digraph are showed in the
+  /// adaptor as an edge (and also as a pair of arcs, of course).
+  /// This adaptor conforms to the \ref concepts::Graph "Graph" concept.
+  ///
+  /// The adapted digraph can also be modified through this adaptor
+  /// by adding or removing nodes or edges, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted digraph.
+  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
+  /// It can also be specified to be \c const.
+  ///
+  /// \note The \c Node type of this adaptor and the adapted digraph are
+  /// convertible to each other, moreover the \c Edge type of the adaptor
+  /// and the \c Arc type of the adapted digraph are also convertible to
+  /// each other.
+  /// (Thus the \c Arc type of the adaptor is convertible to the \c Arc type
+  /// of the adapted digraph.)
+  template<typename GR>
+#ifdef DOXYGEN
+  class Undirector {
+#else
+  class Undirector :
+    public GraphAdaptorExtender<UndirectorBase<GR> > {
+#endif
+  public:
+    /// The type of the adapted digraph.
+    typedef GR Digraph;
+    typedef GraphAdaptorExtender<UndirectorBase<GR> > Parent;
   protected:
     Undirector() { }
 …
     /// \brief Constructor
     ///
     /// Creates a undirected graph from the given digraph
     Undirector(_Digraph& digraph) {
+    /// Creates an undirected graph from the given digraph.
+    Undirector(Digraph& digraph) {
       setDigraph(digraph);
+    }
+    /// \brief ArcMap combined from two original ArcMap
+    ///
+    /// This class adapts two original digraph ArcMap to
+    /// get an arc map on the undirected graph.
+    template <typename _ForwardMap, typename _BackwardMap>
+    /// \brief Arc map combined from two original arc maps
+    ///
+    /// This map adaptor class adapts two arc maps of the underlying
+    /// digraph to get an arc map of the undirected graph.
+    /// Its value type is inherited from the first arc map type
+    /// (\c %ForwardMap).
+    template <typename ForwardMap, typename BackwardMap>
     class CombinedArcMap {
     public:
+      typedef _ForwardMap ForwardMap;
+      typedef _BackwardMap BackwardMap;
+      /// The key type of the map
+      typedef typename Parent::Arc Key;
+      /// The value type of the map
+      typedef typename ForwardMap::Value Value;
       typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag;
       typedef typename ForwardMap::Value Value;
       typedef typename Parent::Arc Key;
       /// \brief Constructor
+      ///
+      typedef typename MapTraits<ForwardMap>::ReturnValue ReturnValue;
+      typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<ForwardMap>::ReturnValue Reference;
+      typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReference;
       /// Constructor
       CombinedArcMap(ForwardMap& forward, BackwardMap& backward)
         : _forward(&forward), _backward(&backward) {}
+      /// \brief Sets the value associated with a key.
+      ///
+      /// Sets the value associated with a key.
+      /// Sets the value associated with the given key.
       void set(const Key& e, const Value& a) {
         if (Parent::direction(e)) {
 …
+      }
+      /// \brief Returns the value associated with a key.
+      ///
+      /// Returns the value associated with a key.
+      typename MapTraits<ForwardMap>::ConstReturnValue
+      operator[](const Key& e) const {
+      /// Returns the value associated with the given key.
+      ConstReturnValue operator[](const Key& e) const {
         if (Parent::direction(e)) {
           return (*_forward)[e];
 …
+      }
+      /// \brief Returns the value associated with a key.
+      ///
+      /// Returns the value associated with a key.
+      typename MapTraits<ForwardMap>::ReturnValue
+      operator[](const Key& e) {
+      /// Returns a reference to the value associated with the given key.
+      ReturnValue operator[](const Key& e) {
         if (Parent::direction(e)) {
           return (*_forward)[e];
 …
     };
     /// \brief Just gives back a combined arc map
     ///
     /// Just gives back a combined arc map
+    /// \brief Returns a combined arc map
+    ///
+    /// This function just returns a combined arc map.
     template <typename ForwardMap, typename BackwardMap>
     static CombinedArcMap<ForwardMap, BackwardMap>
 …
   };
+  /// \brief Just gives back an undirected view of the given digraph
+  ///
+  /// Just gives back an undirected view of the given digraph
+  template<typename Digraph>
+  Undirector<const Digraph>
+  undirector(const Digraph& digraph) {
+    return Undirector<const Digraph>(digraph);
+  /// \brief Returns a read-only Undirector adaptor
+  ///
+  /// This function just returns a read-only \ref Undirector adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates Undirector
+  template<typename GR>
+  Undirector<const GR> undirector(const GR& digraph) {
+    return Undirector<const GR>(digraph);
+  }
   template <typename _Graph, typename _DirectionMap>
 …
     void first(Arc& i) const { _graph->first(i); }
     void firstIn(Arc& i, const Node& n) const {
       bool d;
+      bool d = true;
       _graph->firstInc(i, d, n);
       while (i != INVALID && d == (*_direction)[i]) _graph->nextInc(i, d);
+    }
     void firstOut(Arc& i, const Node& n ) const {
       bool d;
+      bool d = true;
       _graph->firstInc(i, d, n);
       while (i != INVALID && d != (*_direction)[i]) _graph->nextInc(i, d);
 …
     int nodeNum() const { return _graph->nodeNum(); }
     typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
+    typedef EdgeNumTagIndicator<Graph> ArcNumTag;
     int arcNum() const { return _graph->edgeNum(); }
     typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
+    typedef FindEdgeTagIndicator<Graph> FindArcTag;
     Arc findArc(const Node& u, const Node& v,
+                const Arc& prev = INVALID) {
+      Arc arc = prev;
+      bool d = arc == INVALID ? true : (*_direction)[arc];
+      if (d) {
+                const Arc& prev = INVALID) const {
+      Arc arc = _graph->findEdge(u, v, prev);
+      while (arc != INVALID && source(arc) != u) {
         arc = _graph->findEdge(u, v, arc);
-        while (arc != INVALID && !(*_direction)[arc]) {
-          _graph->findEdge(u, v, arc);
+        }
-        if (arc != INVALID) return arc;
+      }
-      _graph->findEdge(v, u, arc);
-      while (arc != INVALID && (*_direction)[arc]) {
-        _graph->findEdge(u, v, arc);
+      }
       return arc;
 …
     Arc addArc(const Node& u, const Node& v) {
       Arc arc = _graph->addArc(u, v);
       _direction->set(arc, _graph->source(arc) == u);
+      Arc arc = _graph->addEdge(u, v);
+      _direction->set(arc, _graph->u(arc) == u);
       return arc;
+    }
 …
   /// \ingroup graph_adaptors
   ///
+  /// \brief Orients the edges of the graph to get a digraph
+  ///
+  /// This adaptor orients each edge in the undirected graph. The
+  /// direction of the arcs stored in an edge node map.  The arcs can
+  /// be easily reverted by the \c reverseArc() member function in the
+  /// adaptor. The Orienter adaptor is conform to the \ref
+  /// concepts::Digraph "Digraph concept".
+  ///
+  /// \tparam _Graph It must be conform to the \ref concepts::Graph
+  /// "Graph concept". The type can be specified to be const.
+  /// \tparam _DirectionMap A bool valued edge map of the the adapted
+  /// graph.
+  ///
+  /// \sa orienter
+  template<typename _Graph,
+           typename DirectionMap = typename _Graph::template EdgeMap<bool> >
+  /// \brief Adaptor class for orienting the edges of a graph to get a digraph
+  ///
+  /// Orienter adaptor can be used for orienting the edges of a graph to
+  /// get a digraph. A \c bool edge map of the underlying graph must be
+  /// specified, which define the direction of the arcs in the adaptor.
+  /// The arcs can be easily reversed by the \c reverseArc() member function
+  /// of the adaptor.
+  /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
+  ///
+  /// The adapted graph can also be modified through this adaptor
+  /// by adding or removing nodes or arcs, unless the \c GR template
+  /// parameter is set to be \c const.
+  ///
+  /// \tparam GR The type of the adapted graph.
+  /// It must conform to the \ref concepts::Graph "Graph" concept.
+  /// It can also be specified to be \c const.
+  /// \tparam DM The type of the direction map.
+  /// It must be a \c bool (or convertible) edge map of the
+  /// adapted graph. The default type is
+  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<bool>".
+  ///
+  /// \note The \c Node type of this adaptor and the adapted graph are
+  /// convertible to each other, moreover the \c Arc type of the adaptor
+  /// and the \c Edge type of the adapted graph are also convertible to
+  /// each other.
+#ifdef DOXYGEN
+  template<typename GR,
+           typename DM>
+  class Orienter {
+#else
+  template<typename GR,
+           typename DM = typename GR::template EdgeMap<bool> >
   class Orienter :
+    public DigraphAdaptorExtender<OrienterBase<_Graph, DirectionMap> > {
+  public:
+    typedef _Graph Graph;
+    typedef DigraphAdaptorExtender<
+      OrienterBase<_Graph, DirectionMap> > Parent;
+    public DigraphAdaptorExtender<OrienterBase<GR, DM> > {
+#endif
+  public:
+    /// The type of the adapted graph.
+    typedef GR Graph;
+    /// The type of the direction edge map.
+    typedef DM DirectionMap;
+    typedef DigraphAdaptorExtender<OrienterBase<GR, DM> > Parent;
     typedef typename Parent::Arc Arc;
   protected:
 …
   public:
     /// \brief Constructor of the adaptor
     ///
     /// Constructor of the adaptor
+    /// \brief Constructor
+    ///
+    /// Constructor of the adaptor.
     Orienter(Graph& graph, DirectionMap& direction) {
       setGraph(graph);
 …
+    }
+    /// \brief Reverse arc
+    ///
+    /// It reverse the given arc. It simply negate the direction in the map.
+    /// \brief Reverses the given arc
+    ///
+    /// This function reverses the given arc.
+    /// It is done by simply negate the assigned value of \c a
+    /// in the direction map.
     void reverseArc(const Arc& a) {
       Parent::reverseArc(a);
 …
   };
+  /// \brief Just gives back a Orienter
+  ///
+  /// Just gives back a Orienter
+  template<typename Graph, typename DirectionMap>
+  Orienter<const Graph, DirectionMap>
+  orienter(const Graph& graph, DirectionMap& dm) {
+    return Orienter<const Graph, DirectionMap>(graph, dm);
+  /// \brief Returns a read-only Orienter adaptor
+  ///
+  /// This function just returns a read-only \ref Orienter adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates Orienter
+  template<typename GR, typename DM>
+  Orienter<const GR, DM>
+  orienter(const GR& graph, DM& direction_map) {
+    return Orienter<const GR, DM>(graph, direction_map);
+  }
   template<typename Graph, typename DirectionMap>
   Orienter<const Graph, const DirectionMap>
   orienter(const Graph& graph, const DirectionMap& dm) {
     return Orienter<const Graph, const DirectionMap>(graph, dm);
+  template<typename GR, typename DM>
+  Orienter<const GR, const DM>
+  orienter(const GR& graph, const DM& direction_map) {
+    return Orienter<const GR, const DM>(graph, direction_map);
+  }
   namespace _adaptor_bits {
     template<typename _Digraph,
              typename _CapacityMap = typename _Digraph::template ArcMap<int>,
              typename _FlowMap = _CapacityMap,
              typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+    template<typename Digraph,
+             typename CapacityMap,
+             typename FlowMap,
+             typename Tolerance>
     class ResForwardFilter {
     public:
-      typedef _Digraph Digraph;
-      typedef _CapacityMap CapacityMap;
-      typedef _FlowMap FlowMap;
-      typedef _Tolerance Tolerance;
       typedef typename Digraph::Arc Key;
 …
     };
     template<typename _Digraph,
              typename _CapacityMap = typename _Digraph::template ArcMap<int>,
              typename _FlowMap = _CapacityMap,
              typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+    template<typename Digraph,
+             typename CapacityMap,
+             typename FlowMap,
+             typename Tolerance>
     class ResBackwardFilter {
     public:
-      typedef _Digraph Digraph;
-      typedef _CapacityMap CapacityMap;
-      typedef _FlowMap FlowMap;
-      typedef _Tolerance Tolerance;
       typedef typename Digraph::Arc Key;
 …
   /// \ingroup graph_adaptors
   ///
   /// \brief An adaptor for composing the residual graph for directed
+  /// \brief Adaptor class for composing the residual digraph for directed
   /// flow and circulation problems.
   ///
+  /// An adaptor for composing the residual graph for directed flow and
+  /// circulation problems.  Let \f$ G=(V, A) \f$ be a directed graph
+  /// and let \f$ F \f$ be a number type. Let moreover \f$ f,c:A\to F \f$,
+  /// be functions on the arc-set.
+  ///
+  /// Then Residual implements the digraph structure with
+  /// node-set \f$ V \f$ and arc-set \f$ A_{forward}\cup A_{backward} \f$,
+  /// where \f$ A_{forward}=\{uv : uv\in A, f(uv)<c(uv)\} \f$ and
+  /// \f$ A_{backward}=\{vu : uv\in A, f(uv)>0\} \f$, i.e. the so
+  /// called residual graph.  When we take the union
+  /// \f$ A_{forward}\cup A_{backward} \f$, multiplicities are counted,
+  /// i.e.  if an arc is in both \f$ A_{forward} \f$ and
+  /// \f$ A_{backward} \f$, then in the adaptor it appears in both
+  /// orientation.
+  ///
+  /// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+  /// "Digraph concept". The type is implicitly const.
+  /// \tparam _CapacityMap An arc map of some numeric type, it defines
+  /// the capacities in the flow problem. The map is implicitly const.
+  /// \tparam _FlowMap An arc map of some numeric type, it defines
+  /// the capacities in the flow problem.
+  /// \tparam _Tolerance Handler for inexact computation.
+  template<typename _Digraph,
+           typename _CapacityMap = typename _Digraph::template ArcMap<int>,
+           typename _FlowMap = _CapacityMap,
+           typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+  class Residual :
+  /// ResidualDigraph can be used for composing the \e residual digraph
+  /// for directed flow and circulation problems. Let \f$ G=(V, A) \f$
+  /// be a directed graph and let \f$ F \f$ be a number type.
+  /// Let \f$ flow, cap: A\to F \f$ be functions on the arcs.
+  /// This adaptor implements a digraph structure with node set \f$ V \f$
+  /// and arc set \f$ A_{forward}\cup A_{backward} \f$,
+  /// where \f$ A_{forward}=\{uv : uv\in A, flow(uv)<cap(uv)\} \f$ and
+  /// \f$ A_{backward}=\{vu : uv\in A, flow(uv)>0\} \f$, i.e. the so
+  /// called residual digraph.
+  /// When the union \f$ A_{forward}\cup A_{backward} \f$ is taken,
+  /// multiplicities are counted, i.e. the adaptor has exactly
+  /// \f$ |A_{forward}| + |A_{backward}|\f$ arcs (it may have parallel
+  /// arcs).
+  /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
+  ///
+  /// \tparam GR The type of the adapted digraph.
+  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
+  /// It is implicitly \c const.
+  /// \tparam CM The type of the capacity map.
+  /// It must be an arc map of some numerical type, which defines
+  /// the capacities in the flow problem. It is implicitly \c const.
+  /// The default type is
+  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
+  /// \tparam FM The type of the flow map.
+  /// It must be an arc map of some numerical type, which defines
+  /// the flow values in the flow problem. The default type is \c CM.
+  /// \tparam TL The tolerance type for handling inexact computation.
+  /// The default tolerance type depends on the value type of the
+  /// capacity map.
+  ///
+  /// \note This adaptor is implemented using Undirector and FilterArcs
+  /// adaptors.
+  ///
+  /// \note The \c Node type of this adaptor and the adapted digraph are
+  /// convertible to each other, moreover the \c Arc type of the adaptor
+  /// is convertible to the \c Arc type of the adapted digraph.
+#ifdef DOXYGEN
+  template<typename GR, typename CM, typename FM, typename TL>
+  class ResidualDigraph
+#else
+  template<typename GR,
+           typename CM = typename GR::template ArcMap<int>,
+           typename FM = CM,
+           typename TL = Tolerance<typename CM::Value> >
+  class ResidualDigraph :
     public FilterArcs<
+    Undirector<const _Digraph>,
+    typename Undirector<const _Digraph>::template CombinedArcMap<
+      _adaptor_bits::ResForwardFilter<const _Digraph, _CapacityMap,
+                                      _FlowMap, _Tolerance>,
+      _adaptor_bits::ResBackwardFilter<const _Digraph, _CapacityMap,
+                                       _FlowMap, _Tolerance> > >
+      Undirector<const GR>,
+      typename Undirector<const GR>::template CombinedArcMap<
+        _adaptor_bits::ResForwardFilter<const GR, CM, FM, TL>,
+        _adaptor_bits::ResBackwardFilter<const GR, CM, FM, TL> > >
+#endif
+  {
   public:
+    typedef _Digraph Digraph;
+    typedef _CapacityMap CapacityMap;
+    typedef _FlowMap FlowMap;
+    typedef _Tolerance Tolerance;
+    /// The type of the underlying digraph.
+    typedef GR Digraph;
+    /// The type of the capacity map.
+    typedef CM CapacityMap;
+    /// The type of the flow map.
+    typedef FM FlowMap;
+    /// The tolerance type.
+    typedef TL Tolerance;
     typedef typename CapacityMap::Value Value;
     typedef Residual Adaptor;
+    typedef ResidualDigraph Adaptor;
   protected:
 …
     typedef typename Undirected::
     template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter;
+      template CombinedArcMap<ForwardFilter, BackwardFilter> ArcFilter;
     typedef FilterArcs<Undirected, ArcFilter> Parent;
 …
   public:
     /// \brief Constructor of the residual digraph.
     ///
     /// Constructor of the residual graph. The parameters are the digraph,
     /// the flow map, the capacity map and a tolerance object.
     Residual(const Digraph& digraph, const CapacityMap& capacity,
              FlowMap& flow, const Tolerance& tolerance = Tolerance())
+    /// \brief Constructor
+    ///
+    /// Constructor of the residual digraph adaptor. The parameters are the
+    /// digraph, the capacity map, the flow map, and a tolerance object.
+    ResidualDigraph(const Digraph& digraph, const CapacityMap& capacity,
+                    FlowMap& flow, const Tolerance& tolerance = Tolerance())
       : Parent(), _capacity(&capacity), _flow(&flow), _graph(digraph),
         _forward_filter(capacity, flow, tolerance),
 …
     typedef typename Parent::Arc Arc;
     /// \brief Gives back the residual capacity of the arc.
     ///
     /// Gives back the residual capacity of the arc.
+    /// \brief Returns the residual capacity of the given arc.
+    ///
+    /// Returns the residual capacity of the given arc.
     Value residualCapacity(const Arc& a) const {
       if (Undirected::direction(a)) {
 …
+    }
     /// \brief Augment on the given arc in the residual graph.
     ///
     /// Augment on the given arc in the residual graph. It increase
     /// or decrease the flow on the original arc depend on the direction
     /// of the residual arc.
+    /// \brief Augments on the given arc in the residual digraph.
+    ///
+    /// Augments on the given arc in the residual digraph. It increases
+    /// or decreases the flow value on the original arc according to the
+    /// direction of the residual arc.
     void augment(const Arc& a, const Value& v) const {
       if (Undirected::direction(a)) {
 …
+    }
+    /// \brief Returns the direction of the arc.
+    ///
+    /// Returns true when the arc is same oriented as the original arc.
+    /// \brief Returns \c true if the given residual arc is a forward arc.
+    ///
+    /// Returns \c true if the given residual arc has the same orientation
+    /// as the original arc, i.e. it is a so called forward arc.
     static bool forward(const Arc& a) {
       return Undirected::direction(a);
+    }
+    /// \brief Returns the direction of the arc.
+    ///
+    /// Returns true when the arc is opposite oriented as the original arc.
+    /// \brief Returns \c true if the given residual arc is a backward arc.
+    ///
+    /// Returns \c true if the given residual arc has the opposite orientation
+    /// than the original arc, i.e. it is a so called backward arc.
     static bool backward(const Arc& a) {
       return !Undirected::direction(a);
+    }
+    /// \brief Gives back the forward oriented residual arc.
+    ///
+    /// Gives back the forward oriented residual arc.
+    /// \brief Returns the forward oriented residual arc.
+    ///
+    /// Returns the forward oriented residual arc related to the given
+    /// arc of the underlying digraph.
     static Arc forward(const typename Digraph::Arc& a) {
       return Undirected::direct(a, true);
+    }
+    /// \brief Gives back the backward oriented residual arc.
+    ///
+    /// Gives back the backward oriented residual arc.
+    /// \brief Returns the backward oriented residual arc.
+    ///
+    /// Returns the backward oriented residual arc related to the given
+    /// arc of the underlying digraph.
     static Arc backward(const typename Digraph::Arc& a) {
       return Undirected::direct(a, false);
 …
     /// \brief Residual capacity map.
     ///
+    /// In generic residual graph the residual capacity can be obtained
+    /// as a map.
+    /// This map adaptor class can be used for obtaining the residual
+    /// capacities as an arc map of the residual digraph.
+    /// Its value type is inherited from the capacity map.
     class ResidualCapacity {
     protected:
       const Adaptor* _adaptor;
     public:
       /// The Key type
+      /// The key type of the map
       typedef Arc Key;
       /// The Value type
       typedef typename _CapacityMap::Value Value;
+      /// The value type of the map
+      typedef typename CapacityMap::Value Value;
       /// Constructor
       ResidualCapacity(const Adaptor& adaptor) : _adaptor(&adaptor) {}
       /// \e
+      /// Returns the value associated with the given residual arc
       Value operator[](const Arc& a) const {
         return _adaptor->residualCapacity(a);
 …
     };
+    /// \brief Returns a residual capacity map
+    ///
+    /// This function just returns a residual capacity map.
+    ResidualCapacity residualCapacity() const {
+      return ResidualCapacity(*this);
+    }
   };
+  /// \brief Returns a (read-only) Residual adaptor
+  ///
+  /// This function just returns a (read-only) \ref Residual adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates Residual
+  template<typename GR, typename CM, typename FM>
+  ResidualDigraph<GR, CM, FM>
+  residualDigraph(const GR& digraph, const CM& capacity_map, FM& flow_map) {
+    return ResidualDigraph<GR, CM, FM> (digraph, capacity_map, flow_map);
+  }
   template <typename _Digraph>
 …
     typedef True NodeNumTag;
     int nodeNum() const {
       return  2 * countNodes(*_digraph);
+    }
     typedef True EdgeNumTag;
+    typedef True ArcNumTag;
     int arcNum() const {
       return countArcs(*_digraph) + countNodes(*_digraph);
+    }
     typedef True FindEdgeTag;
+    typedef True FindArcTag;
     Arc findArc(const Node& u, const Node& v,
                 const Arc& prev = INVALID) const {
+      if (inNode(u)) {
+        if (outNode(v)) {
+          if (static_cast<const DigraphNode&>(u) ==
+              static_cast<const DigraphNode&>(v) && prev == INVALID) {
+            return Arc(u);
+          }
+      if (inNode(u) && outNode(v)) {
+        if (static_cast<const DigraphNode&>(u) ==
+            static_cast<const DigraphNode&>(v) && prev == INVALID) {
+          return Arc(u);
+        }
+      } else {
+        if (inNode(v)) {
+          return Arc(::lemon::findArc(*_digraph, u, v, prev));
+        }
+      }
+      else if (outNode(u) && inNode(v)) {
+        return Arc(::lemon::findArc(*_digraph, u, v, prev));
+      }
       return INVALID;
 …
       typedef Node Key;
       typedef _Value Value;
+      typedef typename MapTraits<NodeImpl>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<NodeImpl>::ReturnValue ReturnValue;
+      typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<NodeImpl>::ReturnValue Reference;
+      typedef typename MapTraits<NodeImpl>::ConstReturnValue ConstReference;
       NodeMapBase(const Adaptor& adaptor)
 …
+      }
+      typename MapTraits<NodeImpl>::ReturnValue
+      operator[](const Node& key) {
+      ReturnValue operator[](const Node& key) {
         if (Adaptor::inNode(key)) { return _in_map[key]; }
         else { return _out_map[key]; }
+      }
+      typename MapTraits<NodeImpl>::ConstReturnValue
+      operator[](const Node& key) const {
+      ConstReturnValue operator[](const Node& key) const {
         if (Adaptor::inNode(key)) { return _in_map[key]; }
         else { return _out_map[key]; }
 …
       typedef Arc Key;
       typedef _Value Value;
+      typedef typename MapTraits<ArcImpl>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<ArcImpl>::ReturnValue ReturnValue;
+      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<ArcImpl>::ReturnValue Reference;
+      typedef typename MapTraits<ArcImpl>::ConstReturnValue ConstReference;
       ArcMapBase(const Adaptor& adaptor)
 …
+      }
+      typename MapTraits<ArcImpl>::ReturnValue
+      operator[](const Arc& key) {
+      ReturnValue operator[](const Arc& key) {
         if (Adaptor::origArc(key)) {
           return _arc_map[key._item.first()];
 …
+      }
+      typename MapTraits<ArcImpl>::ConstReturnValue
+      operator[](const Arc& key) const {
+      ConstReturnValue operator[](const Arc& key) const {
         if (Adaptor::origArc(key)) {
           return _arc_map[key._item.first()];
 …
   /// \ingroup graph_adaptors
   ///
+  /// \brief Split the nodes of a directed graph
+  ///
+  /// The SplitNodes adaptor splits each node into an in-node and an
+  /// out-node. Formaly, the adaptor replaces each \f$ u \f$ node in
+  /// the digraph with two nodes(namely node \f$ u_{in} \f$ and node
+  /// \f$ u_{out} \f$). If there is a \f$ (v, u) \f$ arc in the
+  /// original digraph the new target of the arc will be \f$ u_{in} \f$
+  /// and similarly the source of the original \f$ (u, v) \f$ arc
+  /// will be \f$ u_{out} \f$.  The adaptor will add for each node in
+  /// the original digraph an additional arc which connects
+  /// \f$ (u_{in}, u_{out}) \f$.
+  ///
+  /// The aim of this class is to run algorithm with node costs if the
+  /// algorithm can use directly just arc costs. In this case we should use
+  /// a \c SplitNodes and set the node cost of the graph to the
+  /// bind arc in the adapted graph.
+  ///
+  /// \tparam _Digraph It must be conform to the \ref concepts::Digraph
+  /// "Digraph concept". The type can be specified to be const.
+  template <typename _Digraph>
+  /// \brief Adaptor class for splitting the nodes of a digraph.
+  ///
+  /// SplitNodes adaptor can be used for splitting each node into an
+  /// \e in-node and an \e out-node in a digraph. Formaly, the adaptor
+  /// replaces each node \f$ u \f$ in the digraph with two nodes,
+  /// namely node \f$ u_{in} \f$ and node \f$ u_{out} \f$.
+  /// If there is a \f$ (v, u) \f$ arc in the original digraph, then the
+  /// new target of the arc will be \f$ u_{in} \f$ and similarly the
+  /// source of each original \f$ (u, v) \f$ arc will be \f$ u_{out} \f$.
+  /// The adaptor adds an additional \e bind \e arc from \f$ u_{in} \f$
+  /// to \f$ u_{out} \f$ for each node \f$ u \f$ of the original digraph.
+  ///
+  /// The aim of this class is running an algorithm with respect to node
+  /// costs or capacities if the algorithm considers only arc costs or
+  /// capacities directly.
+  /// In this case you can use \c SplitNodes adaptor, and set the node
+  /// costs/capacities of the original digraph to the \e bind \e arcs
+  /// in the adaptor.
+  ///
+  /// \tparam GR The type of the adapted digraph.
+  /// It must conform to the \ref concepts::Digraph "Digraph" concept.
+  /// It is implicitly \c const.
+  ///
+  /// \note The \c Node type of this adaptor is converible to the \c Node
+  /// type of the adapted digraph.
+  template <typename GR>
+#ifdef DOXYGEN
+  class SplitNodes {
+#else
   class SplitNodes
+    : public DigraphAdaptorExtender<SplitNodesBase<_Digraph> > {
+  public:
+    typedef _Digraph Digraph;
+    typedef DigraphAdaptorExtender<SplitNodesBase<Digraph> > Parent;
+    : public DigraphAdaptorExtender<SplitNodesBase<const GR> > {
+#endif
+  public:
+    typedef GR Digraph;
+    typedef DigraphAdaptorExtender<SplitNodesBase<const GR> > Parent;
     typedef typename Digraph::Node DigraphNode;
 …
     typedef typename Parent::Arc Arc;
     /// \brief Constructor of the adaptor.
+    /// \brief Constructor
     ///
     /// Constructor of the adaptor.
     SplitNodes(Digraph& g) {
+    SplitNodes(const Digraph& g) {
       Parent::setDigraph(g);
+    }
     /// \brief Returns true when the node is in-node.
     ///
     /// Returns true when the node is in-node.
+    /// \brief Returns \c true if the given node is an in-node.
+    ///
+    /// Returns \c true if the given node is an in-node.
     static bool inNode(const Node& n) {
       return Parent::inNode(n);
+    }
     /// \brief Returns true when the node is out-node.
     ///
     /// Returns true when the node is out-node.
+    /// \brief Returns \c true if the given node is an out-node.
+    ///
+    /// Returns \c true if the given node is an out-node.
     static bool outNode(const Node& n) {
       return Parent::outNode(n);
+    }
+    /// \brief Returns true when the arc is arc in the original digraph.
+    ///
+    /// Returns true when the arc is arc in the original digraph.
+    /// \brief Returns \c true if the given arc is an original arc.
+    ///
+    /// Returns \c true if the given arc is one of the arcs in the
+    /// original digraph.
     static bool origArc(const Arc& a) {
       return Parent::origArc(a);
+    }
+    /// \brief Returns true when the arc binds an in-node and an out-node.
+    ///
+    /// Returns true when the arc binds an in-node and an out-node.
+    /// \brief Returns \c true if the given arc is a bind arc.
+    ///
+    /// Returns \c true if the given arc is a bind arc, i.e. it connects
+    /// an in-node and an out-node.
     static bool bindArc(const Arc& a) {
       return Parent::bindArc(a);
+    }
     /// \brief Gives back the in-node created from the \c node.
     ///
     /// Gives back the in-node created from the \c node.
+    /// \brief Returns the in-node created from the given original node.
+    ///
+    /// Returns the in-node created from the given original node.
     static Node inNode(const DigraphNode& n) {
       return Parent::inNode(n);
+    }
     /// \brief Gives back the out-node created from the \c node.
     ///
     /// Gives back the out-node created from the \c node.
+    /// \brief Returns the out-node created from the given original node.
+    ///
+    /// Returns the out-node created from the given original node.
     static Node outNode(const DigraphNode& n) {
       return Parent::outNode(n);
+    }
+    /// \brief Gives back the arc binds the two part of the node.
+    ///
+    /// Gives back the arc binds the two part of the node.
+    /// \brief Returns the bind arc that corresponds to the given
+    /// original node.
+    ///
+    /// Returns the bind arc in the adaptor that corresponds to the given
+    /// original node, i.e. the arc connecting the in-node and out-node
+    /// of \c n.
     static Arc arc(const DigraphNode& n) {
       return Parent::arc(n);
+    }
+    /// \brief Gives back the arc of the original arc.
+    ///
+    /// Gives back the arc of the original arc.
+    /// \brief Returns the arc that corresponds to the given original arc.
+    ///
+    /// Returns the arc in the adaptor that corresponds to the given
+    /// original arc.
     static Arc arc(const DigraphArc& a) {
       return Parent::arc(a);
+    }
+    /// \brief NodeMap combined from two original NodeMap
+    ///
+    /// This class adapt two of the original digraph NodeMap to
+    /// get a node map on the adapted digraph.
+    /// \brief Node map combined from two original node maps
+    ///
+    /// This map adaptor class adapts two node maps of the original digraph
+    /// to get a node map of the split digraph.
+    /// Its value type is inherited from the first node map type
+    /// (\c InNodeMap).
     template <typename InNodeMap, typename OutNodeMap>
     class CombinedNodeMap {
     public:
+      /// The key type of the map
       typedef Node Key;
+      /// The value type of the map
       typedef typename InNodeMap::Value Value;
+      /// \brief Constructor
+      ///
+      /// Constructor.
+      typedef typename MapTraits<InNodeMap>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<InNodeMap>::ReturnValue ReturnValue;
+      typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<InNodeMap>::ReturnValue Reference;
+      typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReference;
+      /// Constructor
       CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map)
         : _in_map(in_map), _out_map(out_map) {}
+      /// \brief The subscript operator.
+      ///
+      /// The subscript operator.
+      /// Returns the value associated with the given key.
+      Value operator[](const Key& key) const {
+        if (Parent::inNode(key)) {
+          return _in_map[key];
+        } else {
+          return _out_map[key];
+        }
+      }
+      /// Returns a reference to the value associated with the given key.
       Value& operator[](const Key& key) {
         if (Parent::inNode(key)) {
 …
+      }
+      /// \brief The const subscript operator.
+      ///
+      /// The const subscript operator.
+      Value operator[](const Key& key) const {
+        if (Parent::inNode(key)) {
+          return _in_map[key];
+        } else {
+          return _out_map[key];
+        }
+      }
+      /// \brief The setter function of the map.
+      ///
+      /// The setter function of the map.
+      /// Sets the value associated with the given key.
       void set(const Key& key, const Value& value) {
         if (Parent::inNode(key)) {
 …
     /// \brief Just gives back a combined node map
     ///
     /// Just gives back a combined node map
+    /// \brief Returns a combined node map
+    ///
+    /// This function just returns a combined node map.
     template <typename InNodeMap, typename OutNodeMap>
     static CombinedNodeMap<InNodeMap, OutNodeMap>
 …
+    }
+    /// \brief ArcMap combined from an original ArcMap and a NodeMap
+    ///
+    /// This class adapt an original ArcMap and a NodeMap to get an
+    /// arc map on the adapted digraph
+    template <typename DigraphArcMap, typename DigraphNodeMap>
+    /// \brief Arc map combined from an arc map and a node map of the
+    /// original digraph.
+    ///
+    /// This map adaptor class adapts an arc map and a node map of the
+    /// original digraph to get an arc map of the split digraph.
+    /// Its value type is inherited from the original arc map type
+    /// (\c ArcMap).
+    template <typename ArcMap, typename NodeMap>
     class CombinedArcMap {
     public:
+      /// The key type of the map
       typedef Arc Key;
+      typedef typename DigraphArcMap::Value Value;
+      /// \brief Constructor
+      ///
+      /// Constructor.
+      CombinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map)
+      /// The value type of the map
+      typedef typename ArcMap::Value Value;
+      typedef typename MapTraits<ArcMap>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<ArcMap>::ReturnValue ReturnValue;
+      typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<ArcMap>::ReturnValue Reference;
+      typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReference;
+      /// Constructor
+      CombinedArcMap(ArcMap& arc_map, NodeMap& node_map)
         : _arc_map(arc_map), _node_map(node_map) {}
+      /// \brief The subscript operator.
+      ///
+      /// The subscript operator.
+      /// Returns the value associated with the given key.
+      Value operator[](const Key& arc) const {
+        if (Parent::origArc(arc)) {
+          return _arc_map[arc];
+        } else {
+          return _node_map[arc];
+        }
+      }
+      /// Returns a reference to the value associated with the given key.
+      Value& operator[](const Key& arc) {
+        if (Parent::origArc(arc)) {
+          return _arc_map[arc];
+        } else {
+          return _node_map[arc];
+        }
+      }
+      /// Sets the value associated with the given key.
       void set(const Arc& arc, const Value& val) {
         if (Parent::origArc(arc)) {
 …
+      }
-      /// \brief The const subscript operator.
-      ///
-      /// The const subscript operator.
-      Value operator[](const Key& arc) const {
-        if (Parent::origArc(arc)) {
-          return _arc_map[arc];
-        } else {
-          return _node_map[arc];
+        }
+      }
-      /// \brief The const subscript operator.
-      ///
-      /// The const subscript operator.
-      Value& operator[](const Key& arc) {
-        if (Parent::origArc(arc)) {
-          return _arc_map[arc];
-        } else {
-          return _node_map[arc];
+        }
+      }
     private:
       DigraphArcMap& _arc_map;
       DigraphNodeMap& _node_map;
+      ArcMap& _arc_map;
+      NodeMap& _node_map;
     };
+    /// \brief Just gives back a combined arc map
+    ///
+    /// Just gives back a combined arc map
+    template <typename DigraphArcMap, typename DigraphNodeMap>
+    static CombinedArcMap<DigraphArcMap, DigraphNodeMap>
+    combinedArcMap(DigraphArcMap& arc_map, DigraphNodeMap& node_map) {
+      return CombinedArcMap<DigraphArcMap, DigraphNodeMap>(arc_map, node_map);
+    }
+    template <typename DigraphArcMap, typename DigraphNodeMap>
+    static CombinedArcMap<const DigraphArcMap, DigraphNodeMap>
+    combinedArcMap(const DigraphArcMap& arc_map, DigraphNodeMap& node_map) {
+      return CombinedArcMap<const DigraphArcMap,
+        DigraphNodeMap>(arc_map, node_map);
+    }
+    template <typename DigraphArcMap, typename DigraphNodeMap>
+    static CombinedArcMap<DigraphArcMap, const DigraphNodeMap>
+    combinedArcMap(DigraphArcMap& arc_map, const DigraphNodeMap& node_map) {
+      return CombinedArcMap<DigraphArcMap,
+        const DigraphNodeMap>(arc_map, node_map);
+    }
+    template <typename DigraphArcMap, typename DigraphNodeMap>
+    static CombinedArcMap<const DigraphArcMap, const DigraphNodeMap>
+    combinedArcMap(const DigraphArcMap& arc_map,
+                   const DigraphNodeMap& node_map) {
+      return CombinedArcMap<const DigraphArcMap,
+        const DigraphNodeMap>(arc_map, node_map);
+    /// \brief Returns a combined arc map
+    ///
+    /// This function just returns a combined arc map.
+    template <typename ArcMap, typename NodeMap>
+    static CombinedArcMap<ArcMap, NodeMap>
+    combinedArcMap(ArcMap& arc_map, NodeMap& node_map) {
+      return CombinedArcMap<ArcMap, NodeMap>(arc_map, node_map);
+    }
+    template <typename ArcMap, typename NodeMap>
+    static CombinedArcMap<const ArcMap, NodeMap>
+    combinedArcMap(const ArcMap& arc_map, NodeMap& node_map) {
+      return CombinedArcMap<const ArcMap, NodeMap>(arc_map, node_map);
+    }
+    template <typename ArcMap, typename NodeMap>
+    static CombinedArcMap<ArcMap, const NodeMap>
+    combinedArcMap(ArcMap& arc_map, const NodeMap& node_map) {
+      return CombinedArcMap<ArcMap, const NodeMap>(arc_map, node_map);
+    }
+    template <typename ArcMap, typename NodeMap>
+    static CombinedArcMap<const ArcMap, const NodeMap>
+    combinedArcMap(const ArcMap& arc_map, const NodeMap& node_map) {
+      return CombinedArcMap<const ArcMap, const NodeMap>(arc_map, node_map);
+    }
   };
+  /// \brief Just gives back a node splitter
+  ///
+  /// Just gives back a node splitter
+  template<typename Digraph>
+  SplitNodes<Digraph>
+  splitNodes(const Digraph& digraph) {
+    return SplitNodes<Digraph>(digraph);
+  /// \brief Returns a (read-only) SplitNodes adaptor
+  ///
+  /// This function just returns a (read-only) \ref SplitNodes adaptor.
+  /// \ingroup graph_adaptors
+  /// \relates SplitNodes
+  template<typename GR>
+  SplitNodes<GR>
+  splitNodes(const GR& digraph) {
+    return SplitNodes<GR>(digraph);
+  }
 } //namespace lemon

lemon/arg_parser.cc

r311	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/arg_parser.h

r311	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/assert.h

r290	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/base.cc

r220	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bfs.h

r420	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bin_heap.h

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/alteration_notifier.h

r361	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/array_map.h

r361	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/base_extender.h

r361	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/bezier.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/default_map.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/enable_if.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/graph_adaptor_extender.h

-                      r416
+                      r455
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   };
-  /// \ingroup digraphbits
-  ///
-  /// \brief Extender for the GraphAdaptors
   template <typename _Graph>
   class GraphAdaptorExtender : public _Graph {

lemon/bits/graph_extender.h

r361	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/map_extender.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/path_dump.h

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/traits.h

r360	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/bits/variant.h

-                      r416
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <lemon/assert.h>
 /// \file
 /// \brief Variant types
+// \file
+// \brief Variant types
 namespace lemon {
 …
   /// \brief Simple Variant type for two types
   ///
   /// Simple Variant type for two types. The Variant type is a type
   /// safe union. The C++ has strong limitations for using unions, by
   /// example we can not store type with non default constructor or
   /// destructor in an union. This class always knowns the current
   /// state of the variant and it cares for the proper construction
   /// and destruction.
+  // \brief Simple Variant type for two types
+  //
+  // Simple Variant type for two types. The Variant type is a type-safe
+  // union. C++ has strong limitations for using unions, for
+  // example you cannot store a type with non-default constructor or
+  // destructor in a union. This class always knowns the current
+  // state of the variant and it cares for the proper construction
+  // and destruction.
   template <typename _First, typename _Second>
   class BiVariant {
   public:
     /// \brief The \c First type.
+    // \brief The \c First type.
     typedef _First First;
     /// \brief The \c Second type.
+    // \brief The \c Second type.
     typedef _Second Second;
     /// \brief Constructor
     ///
     /// This constructor initalizes to the default value of the \c First
     /// type.
+    // \brief Constructor
+    //
+    // This constructor initalizes to the default value of the \c First
+    // type.
     BiVariant() {
       flag = true;
 …
+    }
     /// \brief Constructor
     ///
     /// This constructor initalizes to the given value of the \c First
     /// type.
+    // \brief Constructor
+    //
+    // This constructor initalizes to the given value of the \c First
+    // type.
     BiVariant(const First& f) {
       flag = true;
 …
+    }
     /// \brief Constructor
     ///
     /// This constructor initalizes to the given value of the \c
     /// Second type.
+    // \brief Constructor
+    //
+    // This constructor initalizes to the given value of the \c
+    // Second type.
     BiVariant(const Second& s) {
       flag = false;
 …
+    }
     /// \brief Copy constructor
     ///
     /// Copy constructor
+    // \brief Copy constructor
+    //
+    // Copy constructor
     BiVariant(const BiVariant& bivariant) {
       flag = bivariant.flag;
 …
+    }
     /// \brief Destrcutor
     ///
     /// Destructor
+    // \brief Destrcutor
+    //
+    // Destructor
     ~BiVariant() {
       destroy();
+    }
     /// \brief Set to the default value of the \c First type.
     ///
     /// This function sets the variant to the default value of the \c
     /// First type.
+    // \brief Set to the default value of the \c First type.
+    //
+    // This function sets the variant to the default value of the \c
+    // First type.
     BiVariant& setFirst() {
       destroy();
 …
+    }
     /// \brief Set to the given value of the \c First type.
     ///
     /// This function sets the variant to the given value of the \c
     /// First type.
+    // \brief Set to the given value of the \c First type.
+    //
+    // This function sets the variant to the given value of the \c
+    // First type.
     BiVariant& setFirst(const First& f) {
       destroy();
 …
+    }
     /// \brief Set to the default value of the \c Second type.
     ///
     /// This function sets the variant to the default value of the \c
     /// Second type.
+    // \brief Set to the default value of the \c Second type.
+    //
+    // This function sets the variant to the default value of the \c
+    // Second type.
     BiVariant& setSecond() {
       destroy();
 …
+    }
     /// \brief Set to the given value of the \c Second type.
     ///
     /// This function sets the variant to the given value of the \c
     /// Second type.
+    // \brief Set to the given value of the \c Second type.
+    //
+    // This function sets the variant to the given value of the \c
+    // Second type.
     BiVariant& setSecond(const Second& s) {
       destroy();
 …
+    }
     /// \brief Operator form of the \c setFirst()
+    // \brief Operator form of the \c setFirst()
     BiVariant& operator=(const First& f) {
       return setFirst(f);
+    }
     /// \brief Operator form of the \c setSecond()
+    // \brief Operator form of the \c setSecond()
     BiVariant& operator=(const Second& s) {
       return setSecond(s);
+    }
     /// \brief Assign operator
+    // \brief Assign operator
     BiVariant& operator=(const BiVariant& bivariant) {
       if (this == &bivariant) return *this;
 …
+    }
     /// \brief Reference to the value
     ///
     /// Reference to the value of the \c First type.
     /// \pre The BiVariant should store value of \c First type.
+    // \brief Reference to the value
+    //
+    // Reference to the value of the \c First type.
+    // \pre The BiVariant should store value of \c First type.
     First& first() {
       LEMON_DEBUG(flag, "Variant wrong state");
       return *reinterpret_cast<First*>(data);
+    }
     /// \brief Const reference to the value
     ///
     /// Const reference to the value of the \c First type.
     /// \pre The BiVariant should store value of \c First type.
     const First& first() const {
+      return *reinterpret_cast<First*>(data);
+    }
+    // \brief Const reference to the value
+    //
+    // Const reference to the value of the \c First type.
+    // \pre The BiVariant should store value of \c First type.
+    const First& first() const {
       LEMON_DEBUG(flag, "Variant wrong state");
       return *reinterpret_cast<const First*>(data);
+    }
     /// \brief Operator form of the \c first()
+      return *reinterpret_cast<const First*>(data);
+    }
+    // \brief Operator form of the \c first()
     operator First&() { return first(); }
     /// \brief Operator form of the const \c first()
+    // \brief Operator form of the const \c first()
     operator const First&() const { return first(); }
     /// \brief Reference to the value
     ///
     /// Reference to the value of the \c Second type.
     /// \pre The BiVariant should store value of \c Second type.
     Second& second() {
+    // \brief Reference to the value
+    //
+    // Reference to the value of the \c Second type.
+    // \pre The BiVariant should store value of \c Second type.
+    Second& second() {
       LEMON_DEBUG(!flag, "Variant wrong state");
       return *reinterpret_cast<Second*>(data);
+    }
     /// \brief Const reference to the value
     ///
     /// Const reference to the value of the \c Second type.
     /// \pre The BiVariant should store value of \c Second type.
     const Second& second() const {
+      return *reinterpret_cast<Second*>(data);
+    }
+    // \brief Const reference to the value
+    //
+    // Const reference to the value of the \c Second type.
+    // \pre The BiVariant should store value of \c Second type.
+    const Second& second() const {
       LEMON_DEBUG(!flag, "Variant wrong state");
       return *reinterpret_cast<const Second*>(data);
+    }
     /// \brief Operator form of the \c second()
+      return *reinterpret_cast<const Second*>(data);
+    }
+    // \brief Operator form of the \c second()
     operator Second&() { return second(); }
     /// \brief Operator form of the const \c second()
+    // \brief Operator form of the const \c second()
     operator const Second&() const { return second(); }
     /// \brief %True when the variant is in the first state
     ///
     /// %True when the variant stores value of the \c First type.
+    // \brief %True when the variant is in the first state
+    //
+    // %True when the variant stores value of the \c First type.
     bool firstState() const { return flag; }
     /// \brief %True when the variant is in the second state
     ///
     /// %True when the variant stores value of the \c Second type.
+    // \brief %True when the variant is in the second state
+    //
+    // %True when the variant stores value of the \c Second type.
     bool secondState() const { return !flag; }
 …
+  }
   /// \brief Variant type
   ///
   /// Simple Variant type. The Variant type is a type safe union. The
   /// C++ has strong limitations for using unions, for example we
   /// cannot store type with non default constructor or destructor in
   /// a union. This class always knowns the current state of the
   /// variant and it cares for the proper construction and
   /// destruction.
   ///
   /// \param _num The number of the types which can be stored in the
   /// variant type.
   /// \param _TypeMap This class describes the types of the Variant. The
   /// _TypeMap::Map<index>::Type should be a valid type for each index
   /// in the range {0, 1, ..., _num - 1}. The \c VariantTypeMap is helper
   /// class to define such type mappings up to 10 types.
   ///
   /// And the usage of the class:
   ///\code
   /// typedef Variant<3, VariantTypeMap<int, std::string, double> > MyVariant;
   /// MyVariant var;
   /// var.set<0>(12);
   /// std::cout << var.get<0>() << std::endl;
   /// var.set<1>("alpha");
   /// std::cout << var.get<1>() << std::endl;
   /// var.set<2>(0.75);
   /// std::cout << var.get<2>() << std::endl;
   ///\endcode
   ///
   /// The result of course:
   ///\code
   /// 12
   /// alpha
   /// 0.75
   ///\endcode
+  // \brief Variant type
+  //
+  // Simple Variant type. The Variant type is a type-safe union.
+  // C++ has strong limitations for using unions, for example you
+  // cannot store type with non-default constructor or destructor in
+  // a union. This class always knowns the current state of the
+  // variant and it cares for the proper construction and
+  // destruction.
+  //
+  // \param _num The number of the types which can be stored in the
+  // variant type.
+  // \param _TypeMap This class describes the types of the Variant. The
+  // _TypeMap::Map<index>::Type should be a valid type for each index
+  // in the range {0, 1, ..., _num - 1}. The \c VariantTypeMap is helper
+  // class to define such type mappings up to 10 types.
+  //
+  // And the usage of the class:
+  //\code
+  // typedef Variant<3, VariantTypeMap<int, std::string, double> > MyVariant;
+  // MyVariant var;
+  // var.set<0>(12);
+  // std::cout << var.get<0>() << std::endl;
+  // var.set<1>("alpha");
+  // std::cout << var.get<1>() << std::endl;
+  // var.set<2>(0.75);
+  // std::cout << var.get<2>() << std::endl;
+  //\endcode
+  //
+  // The result of course:
+  //\code
+  // 12
+  // alpha
+  // 0.75
+  //\endcode
   template <int _num, typename _TypeMap>
   class Variant {
 …
     typedef _TypeMap TypeMap;
     /// \brief Constructor
     ///
     /// This constructor initalizes to the default value of the \c type
     /// with 0 index.
+    // \brief Constructor
+    //
+    // This constructor initalizes to the default value of the \c type
+    // with 0 index.
     Variant() {
       flag = 0;
 …
     /// \brief Copy constructor
     ///
     /// Copy constructor
+    // \brief Copy constructor
+    //
+    // Copy constructor
     Variant(const Variant& variant) {
       flag = variant.flag;
 …
+    }
     /// \brief Assign operator
     ///
     /// Assign operator
+    // \brief Assign operator
+    //
+    // Assign operator
     Variant& operator=(const Variant& variant) {
       if (this == &variant) return *this;
 …
+    }
     /// \brief Destrcutor
     ///
     /// Destructor
+    // \brief Destrcutor
+    //
+    // Destructor
     ~Variant() {
       _variant_bits::Memory<num - 1, TypeMap>::destroy(flag, data);
+    }
     /// \brief Set to the default value of the type with \c _idx index.
     ///
     /// This function sets the variant to the default value of the
     /// type with \c _idx index.
+    // \brief Set to the default value of the type with \c _idx index.
+    //
+    // This function sets the variant to the default value of the
+    // type with \c _idx index.
     template <int _idx>
     Variant& set() {
 …
+    }
     /// \brief Set to the given value of the type with \c _idx index.
     ///
     /// This function sets the variant to the given value of the type
     /// with \c _idx index.
+    // \brief Set to the given value of the type with \c _idx index.
+    //
+    // This function sets the variant to the given value of the type
+    // with \c _idx index.
     template <int _idx>
     Variant& set(const typename _TypeMap::template Map<_idx>::Type& init) {
 …
+    }
     /// \brief Gets the current value of the type with \c _idx index.
     ///
     /// Gets the current value of the type with \c _idx index.
+    // \brief Gets the current value of the type with \c _idx index.
+    //
+    // Gets the current value of the type with \c _idx index.
     template <int _idx>
     const typename TypeMap::template Map<_idx>::Type& get() const {
 …
+    }
     /// \brief Gets the current value of the type with \c _idx index.
     ///
     /// Gets the current value of the type with \c _idx index.
+    // \brief Gets the current value of the type with \c _idx index.
+    //
+    // Gets the current value of the type with \c _idx index.
     template <int _idx>
     typename _TypeMap::template Map<_idx>::Type& get() {
 …
+    }
     /// \brief Returns the current state of the variant.
     ///
     /// Returns the current state of the variant.
+    // \brief Returns the current state of the variant.
+    //
+    // Returns the current state of the variant.
     int state() const {
       return flag;
 …
     template <int _idx, typename _T0, typename _T1, typename _T2,
               typename _T3, typename _T5, typename _T4, typename _T6,
+              typename _T3, typename _T4, typename _T5, typename _T6,
               typename _T7, typename _T8, typename _T9>
     struct Mapper {
 …
+  }
   /// \brief Helper class for Variant
   ///
   /// Helper class to define type mappings for Variant. This class
   /// converts the template parameters to be mappable by integer.
   /// \see Variant
+  // \brief Helper class for Variant
+  //
+  // Helper class to define type mappings for Variant. This class
+  // converts the template parameters to be mappable by integer.
+  // \see Variant
   template <
     typename _T0,
     typename _T1 = void, typename _T2 = void, typename _T3 = void,
     typename _T5 = void, typename _T4 = void, typename _T6 = void,
+    typename _T4 = void, typename _T5 = void, typename _T6 = void,
     typename _T7 = void, typename _T8 = void, typename _T9 = void>
   struct VariantTypeMap {

lemon/bits/vector_map.h

r361	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/circulation.h

r420	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/color.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/color.h

r313	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/concept_check.h

r285	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/concepts/digraph.h

r263	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/concepts/graph.h

r263	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/concepts/graph_components.h

r313	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/concepts/heap.h

r290	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/concepts/maps.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/concepts/path.h

r281	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/config.h.in

-                      r1
+                      r459
+/* Define to 1 if you have any LP solver. */
+#undef HAVE_LP
+/* Define to 1 if you have any MIP solver. */
+#undef HAVE_MIP
 /* Define to 1 if you have CPLEX. */
 #undef HAVE_CPLEX
 …
 /* Define to 1 if you have GLPK. */
 #undef HAVE_GLPK
+/* Define to 1 if you have SOPLEX */
+#undef HAVE_SOPLEX
+/* Define to 1 if you have CLP */
+#undef HAVE_CLP

lemon/connectivity.h

-                      r419
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   /// direction.
   ///
   /// \param graph The graph.
+  /// \param digraph The graph.
   /// \return The number of components
   /// \note By definition, the empty graph has zero
 …
   /// that the given graph is DAG.
   ///
   /// \param graph The graph. It must be directed and acyclic.
+  /// \param digraph The graph. It must be directed and acyclic.
   /// \retval order A readable - writable node map. The values will be set
   /// from 0 to the number of the nodes in the graph minus one. Each values

lemon/core.h

-                      r319
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// Construct a new ConEdgeIt iterating on the edges that
     /// connects nodes \c u and \c v.
     ConEdgeIt(const Graph& g, Node u, Node v) : _graph(g) {
       Parent::operator=(findEdge(_graph, u, v));
+    ConEdgeIt(const Graph& g, Node u, Node v) : _graph(g), _u(u), _v(v) {
+      Parent::operator=(findEdge(_graph, _u, _v));
+    }
 …
     /// It increments the iterator and gives back the next edge.
     ConEdgeIt& operator++() {
+      Parent::operator=(findEdge(_graph, _graph.u(*this),
+                                 _graph.v(*this), *this));
+      Parent::operator=(findEdge(_graph, _u, _v, *this));
       return *this;
+    }
   private:
     const Graph& _graph;
+    Node _u, _v;
   };

lemon/counter.h

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/dfs.h

r421	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/dijkstra.h

r408	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/dim2.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/dimacs.h

-                      r388
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     typedef typename Digraph::ArcIt ArcIt;
     if(!comment.empty())
+    if(!comment.empty())
       os << "c " << comment << std::endl;
     os << "p mat " << g.nodeNum() << " " << g.arcNum() << std::endl;

lemon/elevator.h

r383	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/error.h

r291	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/full_graph.h

r360	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/graph_to_eps.h

r313	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/grid_graph.h

r360	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/hao_orlin.h

-                      r412
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
           if (reached[t]) continue;
           _sets.push_front(std::list<int>());
           queue[qlast++] = t;
           reached.set(t, true);
 …
           if (reached[t]) continue;
           _sets.push_front(std::list<int>());
           queue[qlast++] = t;
           reached.set(t, true);

lemon/hypercube_graph.h

r372	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/kruskal.h

r220	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/lgf_reader.h

r319	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).
…	…
871	871	readLine();
872	872	}
873		line.putback(c);
	873	if (readSuccess()) {
	874	line.putback(c);
	875	}
874	876	}
875	877
…	…
1700	1702	readLine();
1701	1703	}
1702		line.putback(c);
	1704	if (readSuccess()) {
	1705	line.putback(c);
	1706	}
1703	1707	}
1704	1708
…	…
2227	2231	readLine();
2228	2232	}
2229		line.putback(c);
	2233	if (readSuccess()) {
	2234	line.putback(c);
	2235	}
2230	2236	}
2231	2237
…	…
2568	2574	readLine();
2569	2575	}
2570		line.putback(c);
	2576	if (readSuccess()) {
	2577	line.putback(c);
	2578	}
2571	2579	}
2572	2580

lemon/lgf_writer.h

r319	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/list_graph.h

r329	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/maps.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/math.h

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/max_matching.h

-                      r330
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
     /// \ref init(), \ref greedyInit() or \ref matchingInit()
     /// functions first, then you can start the algorithm with the \ref
     /// startParse() or startDense() functions.
+    /// startSparse() or startDense() functions.
     ///@{

lemon/nauty_reader.h

r359	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/path.h

r313	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/preflow.h

r420	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/random.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/random.h

r378	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/smart_graph.h

r375	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/suurballe.h

-                      r346
+                      r440
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
   ///
   /// \note For finding node-disjoint paths this algorithm can be used
   /// with \ref SplitDigraphAdaptor.
+  /// with \ref SplitNodes.
 #ifdef DOXYGEN
   template <typename Digraph, typename LengthMap>
 …
   private:
     /// \brief Special implementation of the Dijkstra algorithm
     /// for finding shortest paths in the residual network.
 …
       // The processed (i.e. permanently labeled) nodes
       std::vector<Node> _proc_nodes;
       Node _s;
       Node _t;
 …
     // The length map
     const LengthMap &_length;
     // Arc map of the current flow
     FlowMap *_flow;
 …
     /// This function sets the potential map.
     ///
     /// The potentials provide the dual solution of the underlying
+    /// The potentials provide the dual solution of the underlying
     /// minimum cost flow problem.
     ///
 …
       for (NodeIt n(_graph); n != INVALID; ++n) (*_potential)[n] = 0;
       _dijkstra = new ResidualDijkstra( _graph, *_flow, _length,
+      _dijkstra = new ResidualDijkstra( _graph, *_flow, _length,
                                         *_potential, _pred,
                                         _source, _target );
 …
       return _path_num;
+    }
     /// \brief Compute the paths from the flow.
     ///

lemon/time_measure.h

r314	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/tolerance.h

r280	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

lemon/unionfind.h

-                      r236
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
             if (nodes[nodes[jd].next].size < cmax) {
               pushLeft(nodes[jd].next, nodes[jd].left);
+              if (less(nodes[jd].left, nodes[jd].next)) {
+                nodes[nodes[jd].next].prio = nodes[nodes[jd].left].prio;
+                nodes[nodes[jd].next].item = nodes[nodes[jd].left].item;
+              if (less(jd, nodes[jd].next) ||
+                  nodes[jd].item == nodes[pd].item) {
+                nodes[nodes[jd].next].prio = nodes[jd].prio;
+                nodes[nodes[jd].next].item = nodes[jd].item;
+              }
               popLeft(pd);
 …
               popLeft(nodes[jd].next);
               pushRight(jd, ld);
+              if (less(ld, nodes[jd].left)) {
+              if (less(ld, nodes[jd].left) ||
+                  nodes[ld].item == nodes[pd].item) {
                 nodes[jd].item = nodes[ld].item;
                 nodes[jd].prio = nodes[jd].prio;
+                nodes[jd].prio = nodes[ld].prio;
+              }
               if (nodes[nodes[jd].next].item == nodes[ld].item) {
 …
             if (nodes[nodes[jd].prev].size < cmax) {
               pushRight(nodes[jd].prev, nodes[jd].right);
+              if (less(nodes[jd].right, nodes[jd].prev)) {
+                nodes[nodes[jd].prev].prio = nodes[nodes[jd].right].prio;
+                nodes[nodes[jd].prev].item = nodes[nodes[jd].right].item;
+              if (less(jd, nodes[jd].prev) ||
+                  nodes[jd].item == nodes[pd].item) {
+                nodes[nodes[jd].prev].prio = nodes[jd].prio;
+                nodes[nodes[jd].prev].item = nodes[jd].item;
+              }
               popRight(pd);
 …
               popRight(nodes[jd].prev);
               pushLeft(jd, ld);
+              if (less(ld, nodes[jd].right)) {
+              if (less(ld, nodes[jd].right) ||
+                  nodes[ld].item == nodes[pd].item) {
                 nodes[jd].item = nodes[ld].item;
                 nodes[jd].prio = nodes[jd].prio;
+                nodes[jd].prio = nodes[ld].prio;
+              }
               if (nodes[nodes[jd].prev].item == nodes[ld].item) {
 …
       return comp(nodes[id].prio, nodes[jd].prio);
+    }
-    bool equal(int id, int jd) const {
-      return !less(id, jd) && !less(jd, id);
+    }
   public:
 …
               push(new_id, right_id);
               pushRight(new_id, ~(classes[r].parent));
+              setPrio(new_id);
+              if (less(~classes[r].parent, right_id)) {
+                nodes[new_id].item = nodes[~classes[r].parent].item;
+                nodes[new_id].prio = nodes[~classes[r].parent].prio;
+              } else {
+                nodes[new_id].item = nodes[right_id].item;
+                nodes[new_id].prio = nodes[right_id].prio;
+              }
               id = nodes[id].parent;
 …
               push(new_id, left_id);
               pushLeft(new_id, ~(classes[l].parent));
+              setPrio(new_id);
+              if (less(~classes[l].parent, left_id)) {
+                nodes[new_id].item = nodes[~classes[l].parent].item;
+                nodes[new_id].prio = nodes[~classes[l].parent].prio;
+              } else {
+                nodes[new_id].item = nodes[left_id].item;
+                nodes[new_id].prio = nodes[left_id].prio;
+              }
               id = nodes[id].parent;

m4/lx_check_cplex.m4

-                      r187
+                      r457
     if test x"$lx_cplex_found" = x"yes"; then
       AC_DEFINE([HAVE_CPLEX], [1], [Define to 1 if you have CPLEX.])
+      lx_lp_found=yes
+      AC_DEFINE([HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      lx_mip_found=yes
+      AC_DEFINE([HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
       AC_MSG_RESULT([yes])
     else

m4/lx_check_glpk.m4

-                      r187
+                      r459
+      }
+      #if (GLP_MAJOR_VERSION < 4) \
+         || (GLP_MAJOR_VERSION == 4 && GLP_MINOR_VERSION < 33)
+      #error Supported GLPK versions: 4.33 or above
+      #endif
       int main(int argc, char** argv)
+      {
 …
     if test x"$lx_glpk_found" = x"yes"; then
       AC_DEFINE([HAVE_GLPK], [1], [Define to 1 if you have GLPK.])
+      lx_lp_found=yes
+      AC_DEFINE([HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      lx_mip_found=yes
+      AC_DEFINE([HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
       AC_MSG_RESULT([yes])
     else

m4/lx_check_soplex.m4

r187	r457
57	57	if test x"$lx_soplex_found" = x"yes"; then
58	58	AC_DEFINE([HAVE_SOPLEX], [1], [Define to 1 if you have SOPLEX.])
	59	lx_lp_found=yes
	60	AC_DEFINE([HAVE_LP], [1], [Define to 1 if you have any LP solver.])
59	61	AC_MSG_RESULT([yes])
60	62	else

test/CMakeLists.txt

-                      r468
+                      r469
 SET(TESTS
+  adaptors_test
   bfs_test
+  circulation_test
   counter_test
   dfs_test
 …
   heap_test
   kruskal_test
+  lp_test
+  mip_test
   maps_test
   max_matching_test
+  radix_sort_test
+  path_test
+  preflow_test
   random_test
   path_test
+  suurballe_test
   time_measure_test
   unionfind_test)

test/Makefile.am

-                      r468
+                      r469
 EXTRA_DIST += \
+        test/CMakeLists.txt \
+        test/min_cost_flow_test.lgf \
+        test/preflow_graph.lgf
+        test/CMakeLists.txt
 noinst_HEADERS += \
         test/graph_test.h \
         test/test_tools.h
+        test/test_tools.h
 check_PROGRAMS += \
+        test/adaptors_test \
         test/bfs_test \
         test/circulation_test \
         test/counter_test \
+        test/circulation_test \
+        test/counter_test \
         test/dfs_test \
         test/digraph_test \
         test/dijkstra_test \
         test/dim_test \
+        test/dim_test \
         test/edge_set_test \
         test/error_test \
-        test/graph_adaptor_test \
         test/graph_copy_test \
         test/graph_test \
         test/graph_utils_test \
+        test/hao_orlin_test \
         test/heap_test \
         test/kruskal_test \
+        test/hao_orlin_test \
+        test/maps_test \
+        test/maps_test \
         test/max_matching_test \
+        test/random_test \
+        test/path_test \
+        test/preflow_test \
+        test/suurballe_test \
+        test/test_tools_fail \
+        test/test_tools_pass \
+        test/time_measure_test \
+        test/path_test \
+        test/preflow_test \
+        test/radix_sort_test \
+        test/random_test \
+        test/suurballe_test \
+        test/test_tools_fail \
+        test/test_tools_pass \
+        test/time_measure_test \
         test/unionfind_test
+if HAVE_LP
+check_PROGRAMS += test/lp_test
+endif HAVE_LP
+if HAVE_MIP
+check_PROGRAMS += test/mip_test
+endif HAVE_MIP
 TESTS += $(check_PROGRAMS)
 XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
+test_adaptors_test_SOURCES = test/adaptors_test.cc
 test_bfs_test_SOURCES = test/bfs_test.cc
 test_circulation_test_SOURCES = test/circulation_test.cc
 …
 test_edge_set_test_SOURCES = test/edge_set_test.cc
 test_error_test_SOURCES = test/error_test.cc
-test_graph_adaptor_test_SOURCES = test/graph_adaptor_test.cc
 test_graph_copy_test_SOURCES = test/graph_copy_test.cc
 test_graph_test_SOURCES = test/graph_test.cc
 …
 test_kruskal_test_SOURCES = test/kruskal_test.cc
 test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
+test_lp_test_SOURCES = test/lp_test.cc
 test_maps_test_SOURCES = test/maps_test.cc
+test_mip_test_SOURCES = test/mip_test.cc
 test_max_matching_test_SOURCES = test/max_matching_test.cc
 test_path_test_SOURCES = test/path_test.cc
 test_preflow_test_SOURCES = test/preflow_test.cc
+test_radix_sort_test_SOURCES = test/radix_sort_test.cc
 test_suurballe_test_SOURCES = test/suurballe_test.cc
 test_random_test_SOURCES = test/random_test.cc

test/bfs_test.cc

r293	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/circulation_test.cc

r403	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/counter_test.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/dfs_test.cc

r293	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/digraph_test.cc

r375	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/dijkstra_test.cc

r397	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/dim_test.cc

r253	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/error_test.cc

r277	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/graph_copy_test.cc

r282	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/graph_test.cc

r375	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/graph_test.h

r374	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/graph_utils_test.cc

r220	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/hao_orlin_test.cc

r410	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/heap_test.cc

r293	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/kruskal_test.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/maps_test.cc

r210	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/max_matching_test.cc

r327	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/path_test.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/preflow_test.cc

-                      r394
+                      r440
  * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
  */
+#include <fstream>
+#include <string>
+#include <iostream>
 #include "test_tools.h"
 …
 using namespace lemon;
+char test_lgf[] =
+  "@nodes\n"
+  "label\n"
+  "0\n"
+  "1\n"
+  "2\n"
+  "3\n"
+  "4\n"
+  "5\n"
+  "6\n"
+  "7\n"
+  "8\n"
+  "9\n"
+  "@arcs\n"
+  "    label capacity\n"
+  "0 1 0     20\n"
+  "0 2 1     0\n"
+  "1 1 2     3\n"
+  "1 2 3     8\n"
+  "1 3 4     8\n"
+  "2 5 5     5\n"
+  "3 2 6     5\n"
+  "3 5 7     5\n"
+  "3 6 8     5\n"
+  "4 3 9     3\n"
+  "5 7 10    3\n"
+  "5 6 11    10\n"
+  "5 8 12    10\n"
+  "6 8 13    8\n"
+  "8 9 14    20\n"
+  "8 1 15    5\n"
+  "9 5 16    5\n"
+  "@attributes\n"
+  "source 1\n"
+  "target 8\n";
 void checkPreflowCompile()
 …
   typedef Preflow<Digraph, CapMap> PType;
-  std::string f_name;
-  if( getenv("srcdir") )
-    f_name = std::string(getenv("srcdir"));
-  else f_name = ".";
-  f_name += "/test/preflow_graph.lgf";
-  std::ifstream file(f_name.c_str());
-  check(file, "Input file '" << f_name << "' not found.");
   Digraph g;
   Node s, t;
   CapMap cap(g);
+  DigraphReader<Digraph>(g,file).
+  std::istringstream input(test_lgf);
+  DigraphReader<Digraph>(g,input).
     arcMap("capacity", cap).
     node("source",s).

test/random_test.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/suurballe_test.cc

-                      r346
+                      r440
 /* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
  * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
  * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
 …
 #include <iostream>
-#include <fstream>
 #include <lemon/list_graph.h>
 …
 using namespace lemon;
+char test_lgf[] =
+  "@nodes\n"
+  "label supply1 supply2 supply3\n"
+  "1     0        20      27\n"
+  "2     0       -4        0\n"
+  "3     0        0        0\n"
+  "4     0        0        0\n"
+  "5     0        9        0\n"
+  "6     0       -6        0\n"
+  "7     0        0        0\n"
+  "8     0        0        0\n"
+  "9     0        3        0\n"
+  "10    0       -2        0\n"
+  "11    0        0        0\n"
+  "12    0       -20     -27\n"
+  "@arcs\n"
+  "      cost capacity lower1 lower2\n"
+  " 1  2  70  11       0      8\n"
+  " 1  3 150   3       0      1\n"
+  " 1  4  80  15       0      2\n"
+  " 2  8  80  12       0      0\n"
+  " 3  5 140   5       0      3\n"
+  " 4  6  60  10       0      1\n"
+  " 4  7  80   2       0      0\n"
+  " 4  8 110   3       0      0\n"
+  " 5  7  60  14       0      0\n"
+  " 5 11 120  12       0      0\n"
+  " 6  3   0   3       0      0\n"
+  " 6  9 140   4       0      0\n"
+  " 6 10  90   8       0      0\n"
+  " 7  1  30   5       0      0\n"
+  " 8 12  60  16       0      4\n"
+  " 9 12  50   6       0      0\n"
+  "10 12  70  13       0      5\n"
+  "10  2 100   7       0      0\n"
+  "10  7  60  10       0      0\n"
+  "11 10  20  14       0      6\n"
+  "12 11  30  10       0      0\n"
+  "@attributes\n"
+  "source  1\n"
+  "target 12\n"
+  "@end\n";
 // Check the feasibility of the flow
 template <typename Digraph, typename FlowMap>
 bool checkFlow( const Digraph& gr, const FlowMap& flow,
+bool checkFlow( const Digraph& gr, const FlowMap& flow,
                 typename Digraph::Node s, typename Digraph::Node t,
                 int value )
 …
 // Check the optimalitiy of the flow
 template < typename Digraph, typename CostMap,
+template < typename Digraph, typename CostMap,
            typename FlowMap, typename PotentialMap >
 bool checkOptimality( const Digraph& gr, const CostMap& cost,
 …
   Node source, target;
+  std::string fname;
+  if(getenv("srcdir"))
+    fname = std::string(getenv("srcdir"));
+  else fname = ".";
+  fname += "/test/min_cost_flow_test.lgf";
+  std::ifstream input(fname.c_str());
+  check(input, "Input file '" << fname << "' not found");
+  std::istringstream input(test_lgf);
   DigraphReader<ListDigraph>(digraph, input).
     arcMap("cost", length).
 …
     node("target", target).
     run();
+  input.close();
   // Find 2 paths
+  {
 …
           "The flow is not feasible");
     check(suurballe.totalLength() == 510, "The flow is not optimal");
     check(checkOptimality(digraph, length, suurballe.flowMap(),
+    check(checkOptimality(digraph, length, suurballe.flowMap(),
                           suurballe.potentialMap()),
           "Wrong potentials");
 …
           "The flow is not feasible");
     check(suurballe.totalLength() == 1040, "The flow is not optimal");
     check(checkOptimality(digraph, length, suurballe.flowMap(),
+    check(checkOptimality(digraph, length, suurballe.flowMap(),
                           suurballe.potentialMap()),
           "Wrong potentials");
 …
           "The flow is not feasible");
     check(suurballe.totalLength() == 1040, "The flow is not optimal");
     check(checkOptimality(digraph, length, suurballe.flowMap(),
+    check(checkOptimality(digraph, length, suurballe.flowMap(),
                           suurballe.potentialMap()),
           "Wrong potentials");

test/test_tools.h

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/test_tools_fail.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/test_tools_pass.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/time_measure_test.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

test/unionfind_test.cc

r209	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

tools/dimacs-to-lgf.cc

r387	r440
3	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5		* Copyright (C) 2003-2008
	5	* Copyright (C) 2003-2009
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).

tools/lemon-0.x-to-1.x.sh

-                      r366
+                      r466
         -e "s/\<BoundingBox\>/Box/g"\
         -e "s/\<readNauty\>/readNautyGraph/g"\
+        -e "s/\<RevDigraphAdaptor\>/ReverseDigraph/g"\
+        -e "s/\<revDigraphAdaptor\>/reverseDigraph/g"\
+        -e "s/\<SubDigraphAdaptor\>/SubDigraph/g"\
+        -e "s/\<subDigraphAdaptor\>/subDigraph/g"\
+        -e "s/\<SubGraphAdaptor\>/SubGraph/g"\
+        -e "s/\<subGraphAdaptor\>/subGraph/g"\
+        -e "s/\<NodeSubDigraphAdaptor\>/FilterNodes/g"\
+        -e "s/\<nodeSubDigraphAdaptor\>/filterNodes/g"\
+        -e "s/\<ArcSubDigraphAdaptor\>/FilterArcs/g"\
+        -e "s/\<arcSubDigraphAdaptor\>/filterArcs/g"\
+        -e "s/\<UndirDigraphAdaptor\>/Undirector/g"\
+        -e "s/\<undirDigraphAdaptor\>/undirector/g"\
+        -e "s/\<ResDigraphAdaptor\>/ResidualDigraph/g"\
+        -e "s/\<resDigraphAdaptor\>/residualDigraph/g"\
+        -e "s/\<SplitDigraphAdaptor\>/SplitNodes/g"\
+        -e "s/\<splitDigraphAdaptor\>/splitNodes/g"\
+        -e "s/\<SubGraphAdaptor\>/SubGraph/g"\
+        -e "s/\<subGraphAdaptor\>/subGraph/g"\
+        -e "s/\<NodeSubGraphAdaptor\>/FilterNodes/g"\
+        -e "s/\<nodeSubGraphAdaptor\>/filterNodes/g"\
+        -e "s/\<ArcSubGraphAdaptor\>/FilterEdges/g"\
+        -e "s/\<arcSubGraphAdaptor\>/filterEdges/g"\
+        -e "s/\<DirGraphAdaptor\>/Orienter/g"\
+        -e "s/\<dirGraphAdaptor\>/orienter/g"\
     <$i > $TMP
     mv $TMP $i

Context Navigation

Changes in / [468:68fe66e2b34a:469:04c0631fd332] in lemon-main

Legend:

Download in other formats: