Index: lemon/CMakeLists.txt
===================================================================
--- lemon/CMakeLists.txt	(revision 1230)
+++ lemon/CMakeLists.txt	(revision 1113)
@@ -5,10 +5,10 @@
 
 CONFIGURE_FILE(
-  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
+  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/config.h
 )
 
 CONFIGURE_FILE(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.in
+  ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
   @ONLY
@@ -37,5 +37,5 @@
 IF(LEMON_HAVE_CPLEX)
   SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc)
-  INCLUDE_DIRECTORIES(${ILOG_INCLUDE_DIRS})
+  INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS})
 ENDIF()
 
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am	(revision 1106)
+++ lemon/Makefile.am	(revision 1106)
@@ -0,0 +1,137 @@
+EXTRA_DIST += \
+	lemon/lemon.pc.in \
+	lemon/lemon.pc.cmake \
+	lemon/CMakeLists.txt \
+	lemon/config.h.cmake
+
+pkgconfig_DATA += lemon/lemon.pc
+
+lib_LTLIBRARIES += lemon/libemon.la
+
+lemon_libemon_la_SOURCES = \
+	lemon/arg_parser.cc \
+	lemon/base.cc \
+	lemon/color.cc \
+	lemon/lp_base.cc \
+	lemon/lp_skeleton.cc \
+	lemon/random.cc \
+	lemon/bits/windows.cc
+
+nodist_lemon_HEADERS = lemon/config.h	
+
+lemon_libemon_la_CXXFLAGS = \
+	$(AM_CXXFLAGS) \
+	$(GLPK_CFLAGS) \
+	$(CPLEX_CFLAGS) \
+	$(SOPLEX_CXXFLAGS) \
+	$(CLP_CXXFLAGS) \
+	$(CBC_CXXFLAGS)
+
+lemon_libemon_la_LDFLAGS = \
+	$(GLPK_LIBS) \
+	$(CPLEX_LIBS) \
+	$(SOPLEX_LIBS) \
+	$(CLP_LIBS) \
+	$(CBC_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
+
+if HAVE_CBC
+lemon_libemon_la_SOURCES += lemon/cbc.cc
+endif
+
+lemon_HEADERS += \
+	lemon/adaptors.h \
+	lemon/arg_parser.h \
+	lemon/assert.h \
+	lemon/bfs.h \
+	lemon/bin_heap.h \
+	lemon/bucket_heap.h \
+	lemon/cbc.h \
+	lemon/circulation.h \
+	lemon/clp.h \
+	lemon/color.h \
+	lemon/concept_check.h \
+	lemon/connectivity.h \
+	lemon/counter.h \
+	lemon/core.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/euler.h \
+	lemon/fib_heap.h \
+	lemon/full_graph.h \
+	lemon/glpk.h \
+	lemon/gomory_hu.h \
+	lemon/graph_to_eps.h \
+	lemon/grid_graph.h \
+	lemon/hypercube_graph.h \
+	lemon/kruskal.h \
+	lemon/hao_orlin.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/maps.h \
+	lemon/matching.h \
+	lemon/math.h \
+	lemon/min_cost_arborescence.h \
+	lemon/nauty_reader.h \
+	lemon/network_simplex.h \
+	lemon/path.h \
+	lemon/preflow.h \
+	lemon/radix_heap.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/unionfind.h \
+	lemon/bits/windows.h
+
+bits_HEADERS += \
+	lemon/bits/alteration_notifier.h \
+	lemon/bits/array_map.h \
+	lemon/bits/bezier.h \
+	lemon/bits/default_map.h \
+	lemon/bits/edge_set_extender.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/bits/vector_map.h
+
+concept_HEADERS += \
+	lemon/concepts/digraph.h \
+	lemon/concepts/graph.h \
+	lemon/concepts/graph_components.h \
+	lemon/concepts/heap.h \
+	lemon/concepts/maps.h \
+	lemon/concepts/path.h
Index: lemon/adaptors.h
===================================================================
--- lemon/adaptors.h	(revision 1159)
+++ lemon/adaptors.h	(revision 1157)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -361,7 +361,4 @@
   /// parameter is set to be \c const.
   ///
-  /// This class provides item counting in the same time as the adapted
-  /// digraph structure.
-  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
@@ -422,5 +419,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -509,9 +506,9 @@
 
     template <typename V>
-    class NodeMap
-      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
+    class NodeMap 
+      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, 
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
+	LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
     public:
@@ -536,7 +533,7 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
@@ -583,5 +580,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -652,8 +649,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, 
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
@@ -679,5 +676,5 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
@@ -722,6 +719,4 @@
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
@@ -1022,8 +1017,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1049,8 +1044,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1076,8 +1071,8 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
@@ -1118,6 +1113,6 @@
     NF* _node_filter;
     EF* _edge_filter;
-    SubGraphBase()
-          : Parent(), _node_filter(0), _edge_filter(0) { }
+    SubGraphBase() 
+	  : Parent(), _node_filter(0), _edge_filter(0) { }
 
     void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
@@ -1220,8 +1215,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1247,8 +1242,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1274,9 +1269,9 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
+	LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
     public:
@@ -1319,6 +1314,4 @@
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes, edges and arcs.
   ///
   /// \tparam GR The type of the adapted graph.
@@ -1478,6 +1471,4 @@
   /// by adding or removing nodes or arcs/edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time item counting.
   ///
   /// \tparam GR The type of the adapted digraph or graph.
@@ -1505,5 +1496,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, 
                      true> > Parent;
 
@@ -1526,5 +1517,5 @@
     /// Creates a subgraph for the given digraph or graph with the
     /// given node filter map.
-    FilterNodes(GR& graph, NF& node_filter)
+    FilterNodes(GR& graph, NF& node_filter) 
       : Parent(), const_true_map()
     {
@@ -1564,9 +1555,9 @@
                     typename enable_if<UndirectedTagIndicator<GR> >::type> :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > {
 
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > Parent;
 
@@ -1628,6 +1619,4 @@
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
@@ -1654,5 +1643,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
+      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, 
                      AF, false> > Parent;
 
@@ -1740,6 +1729,4 @@
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes, edges and arcs.
   ///
   /// \tparam GR The type of the adapted graph.
@@ -1762,9 +1749,9 @@
   class FilterEdges :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >, 
                    EF, false> > {
 #endif
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >, 
                    EF, false> > Parent;
 
@@ -1791,5 +1778,5 @@
     /// Creates a subgraph for the given graph with the given edge
     /// filter map.
-    FilterEdges(GR& graph, EF& edge_filter)
+    FilterEdges(GR& graph, EF& edge_filter) 
       : Parent(), const_true_map() {
       Parent::initialize(graph, const_true_map, edge_filter);
@@ -1859,5 +1846,5 @@
       bool _forward;
 
-      Arc(const Edge& edge, bool forward)
+      Arc(const Edge& edge, bool forward) 
         : _edge(edge), _forward(forward) {}
 
@@ -2099,5 +2086,5 @@
 
       ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
-        : _forward(*adaptor._digraph, value),
+        : _forward(*adaptor._digraph, value), 
           _backward(*adaptor._digraph, value) {}
 
@@ -2217,5 +2204,5 @@
     typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
     EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
-
+    
     typedef EdgeNotifier ArcNotifier;
     ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
@@ -2245,7 +2232,4 @@
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides item counting in the same time as the adapted
-  /// digraph structure.
   ///
   /// \tparam DGR The type of the adapted digraph.
@@ -2551,7 +2535,4 @@
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides item counting in the same time as the adapted
-  /// graph structure.
   ///
   /// \tparam GR The type of the adapted graph.
@@ -2698,6 +2679,4 @@
   /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
   ///
-  /// This class provides only linear time counting for nodes and arcs.
-  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
@@ -2729,5 +2708,5 @@
            typename FM = CM,
            typename TL = Tolerance<typename CM::Value> >
-  class ResidualDigraph
+  class ResidualDigraph 
     : public SubDigraph<
         Undirector<const DGR>,
@@ -2786,5 +2765,5 @@
     ResidualDigraph(const DGR& digraph, const CM& capacity,
                     FM& flow, const TL& tolerance = Tolerance())
-      : Parent(), _capacity(&capacity), _flow(&flow),
+      : Parent(), _capacity(&capacity), _flow(&flow), 
         _graph(digraph), _node_filter(),
         _forward_filter(capacity, flow, tolerance),
@@ -2868,5 +2847,5 @@
 
       /// Constructor
-      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
+      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor) 
         : _adaptor(&adaptor) {}
 
@@ -3347,7 +3326,4 @@
   /// in the adaptor.
   ///
-  /// This class provides item counting in the same time as the adapted
-  /// digraph structure.
-  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
@@ -3448,5 +3424,5 @@
     /// to get a node map of the split digraph.
     /// Its value type is inherited from the first node map type (\c IN).
-    /// \tparam IN The type of the node map for the in-nodes.
+    /// \tparam IN The type of the node map for the in-nodes. 
     /// \tparam OUT The type of the node map for the out-nodes.
     template <typename IN, typename OUT>
Index: lemon/arg_parser.cc
===================================================================
--- lemon/arg_parser.cc	(revision 956)
+++ lemon/arg_parser.cc	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -21,21 +21,12 @@
 namespace lemon {
 
-  void ArgParser::_terminate(ArgParserException::Reason reason) const
-  {
-    if(_exit_on_problems)
-      exit(1);
-    else throw(ArgParserException(reason));
-  }
-
-
   void ArgParser::_showHelp(void *p)
   {
     (static_cast<ArgParser*>(p))->showHelp();
-    (static_cast<ArgParser*>(p))->_terminate(ArgParserException::HELP);
+    exit(1);
   }
 
   ArgParser::ArgParser(int argc, const char * const *argv)
-    :_argc(argc), _argv(argv), _command_name(argv[0]),
-    _exit_on_problems(true) {
+    :_argc(argc), _argv(argv), _command_name(argv[0]) {
     funcOption("-help","Print a short help message",_showHelp,this);
     synonym("help","-help");
@@ -352,5 +343,5 @@
         i!=_others_help.end();++i) showHelp(i);
     for(Opts::const_iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);
-    _terminate(ArgParserException::HELP);
+    exit(1);
   }
 
@@ -361,5 +352,5 @@
     std::cerr << "\nType '" << _command_name <<
       " --help' to obtain a short summary on the usage.\n\n";
-    _terminate(ArgParserException::UNKNOWN_OPT);
+    exit(1);
   }
 
@@ -424,5 +415,5 @@
       std::cerr << "\nType '" << _command_name <<
         " --help' to obtain a short summary on the usage.\n\n";
-      _terminate(ArgParserException::INVALID_OPT);
+      exit(1);
     }
   }
Index: lemon/arg_parser.h
===================================================================
--- lemon/arg_parser.h	(revision 959)
+++ lemon/arg_parser.h	(revision 463)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -34,49 +34,4 @@
 
 namespace lemon {
-
-  ///Exception used by ArgParser
-
-  ///Exception used by ArgParser.
-  ///
-  class ArgParserException : public Exception {
-  public:
-    /// Reasons for failure
-
-    /// Reasons for failure.
-    ///
-    enum Reason {
-      HELP,         ///< <tt>--help</tt> option was given.
-      UNKNOWN_OPT,  ///< Unknown option was given.
-      INVALID_OPT   ///< Invalid combination of options.
-    };
-
-  private:
-    Reason _reason;
-
-  public:
-    ///Constructor
-    ArgParserException(Reason r) throw() : _reason(r) {}
-    ///Virtual destructor
-    virtual ~ArgParserException() throw() {}
-    ///A short description of the exception
-    virtual const char* what() const throw() {
-      switch(_reason)
-        {
-        case HELP:
-          return "lemon::ArgParseException: ask for help";
-          break;
-        case UNKNOWN_OPT:
-          return "lemon::ArgParseException: unknown option";
-          break;
-        case INVALID_OPT:
-          return "lemon::ArgParseException: invalid combination of options";
-          break;
-        }
-      return "";
-    }
-    ///Return the reason for the failure
-    Reason reason() const {return _reason; }
-  };
-
 
   ///Command line arguments parser
@@ -162,8 +117,4 @@
                     void (*func)(void *),void *data);
 
-    bool _exit_on_problems;
-
-    void _terminate(ArgParserException::Reason reason) const;
-
   public:
 
@@ -430,9 +381,4 @@
     const std::vector<std::string> &files() const { return _file_args; }
 
-    ///Throw instead of exit in case of problems
-    void throwOnProblems()
-    {
-      _exit_on_problems=false;
-    }
   };
 }
Index: lemon/assert.h
===================================================================
--- lemon/assert.h	(revision 1242)
+++ lemon/assert.h	(revision 463)
@@ -200,5 +200,5 @@
                              ::lemon::_assert_bits::cstringify(msg),    \
                              #exp), 0)))
-#    if defined LEMON_ENABLE_DEBUG
+#    if LEMON_ENABLE_DEBUG
 #      define LEMON_DEBUG(exp, msg)                                     \
          (static_cast<void> (!!(exp) ? 0 : (                            \
Index: lemon/base.cc
===================================================================
--- lemon/base.cc	(revision 1222)
+++ lemon/base.cc	(revision 554)
@@ -22,5 +22,4 @@
 #include<lemon/tolerance.h>
 #include<lemon/core.h>
-#include<lemon/time_measure.h>
 namespace lemon {
 
@@ -33,5 +32,3 @@
 #endif
 
-  TimeStamp::Format TimeStamp::_format = TimeStamp::NORMAL;
-
 } //namespace lemon
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 1254)
+++ 	(revision )
@@ -1,1116 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BELLMAN_FORD_H
-#define LEMON_BELLMAN_FORD_H
-
-/// \ingroup shortest_path
-/// \file
-/// \brief Bellman-Ford algorithm.
-
-#include <lemon/list_graph.h>
-#include <lemon/bits/path_dump.h>
-#include <lemon/core.h>
-#include <lemon/error.h>
-#include <lemon/maps.h>
-#include <lemon/path.h>
-
-#include <limits>
-
-namespace lemon {
-
-  /// \brief Default OperationTraits for the BellmanFord algorithm class.
-  ///
-  /// This operation traits class defines all computational operations
-  /// and constants that are used in the Bellman-Ford algorithm.
-  /// The default implementation is based on the \c numeric_limits class.
-  /// If the numeric type does not have infinity value, then the maximum
-  /// value is used as extremal infinity value.
-  template <
-    typename V,
-    bool has_inf = std::numeric_limits<V>::has_infinity>
-  struct BellmanFordDefaultOperationTraits {
-    /// \e
-    typedef V Value;
-    /// \brief Gives back the zero value of the type.
-    static Value zero() {
-      return static_cast<Value>(0);
-    }
-    /// \brief Gives back the positive infinity value of the type.
-    static Value infinity() {
-      return std::numeric_limits<Value>::infinity();
-    }
-    /// \brief Gives back the sum of the given two elements.
-    static Value plus(const Value& left, const Value& right) {
-      return left + right;
-    }
-    /// \brief Gives back \c true only if the first value is less than
-    /// the second.
-    static bool less(const Value& left, const Value& right) {
-      return left < right;
-    }
-  };
-
-  template <typename V>
-  struct BellmanFordDefaultOperationTraits<V, false> {
-    typedef V Value;
-    static Value zero() {
-      return static_cast<Value>(0);
-    }
-    static Value infinity() {
-      return std::numeric_limits<Value>::max();
-    }
-    static Value plus(const Value& left, const Value& right) {
-      if (left == infinity() || right == infinity()) return infinity();
-      return left + right;
-    }
-    static bool less(const Value& left, const Value& right) {
-      return left < right;
-    }
-  };
-
-  /// \brief Default traits class of BellmanFord class.
-  ///
-  /// Default traits class of BellmanFord class.
-  /// \param GR The type of the digraph.
-  /// \param LEN The type of the length map.
-  template<typename GR, typename LEN>
-  struct BellmanFordDefaultTraits {
-    /// The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \brief The type of the map that stores the arc lengths.
-    ///
-    /// The type of the map that stores the arc lengths.
-    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LEN LengthMap;
-
-    /// The type of the arc lengths.
-    typedef typename LEN::Value Value;
-
-    /// \brief Operation traits for Bellman-Ford algorithm.
-    ///
-    /// It defines the used operations and the infinity value for the
-    /// given \c Value type.
-    /// \see BellmanFordDefaultOperationTraits
-    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
-
-    /// \brief The type of the map that stores the last arcs of the
-    /// shortest paths.
-    ///
-    /// The type of the map that stores the last
-    /// arcs of the shortest paths.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
-
-    /// \brief Instantiates a \c PredMap.
-    ///
-    /// This function instantiates a \ref PredMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref PredMap.
-    static PredMap *createPredMap(const GR& g) {
-      return new PredMap(g);
-    }
-
-    /// \brief The type of the map that stores the distances of the nodes.
-    ///
-    /// The type of the map that stores the distances of the nodes.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<typename LEN::Value> DistMap;
-
-    /// \brief Instantiates a \c DistMap.
-    ///
-    /// This function instantiates a \ref DistMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref DistMap.
-    static DistMap *createDistMap(const GR& g) {
-      return new DistMap(g);
-    }
-
-  };
-
-  /// \brief %BellmanFord algorithm class.
-  ///
-  /// \ingroup shortest_path
-  /// This class provides an efficient implementation of the Bellman-Ford
-  /// algorithm. The maximum time complexity of the algorithm is
-  /// <tt>O(nm)</tt>.
-  ///
-  /// The Bellman-Ford algorithm solves the single-source shortest path
-  /// problem when the arcs can have negative lengths, but the digraph
-  /// should not contain directed cycles with negative total length.
-  /// If all arc costs are non-negative, consider to use the Dijkstra
-  /// algorithm instead, since it is more efficient.
-  ///
-  /// The arc lengths are passed to the algorithm using a
-  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
-  /// kind of length. The type of the length values is determined by the
-  /// \ref concepts::ReadMap::Value "Value" type of the length map.
-  ///
-  /// There is also a \ref bellmanFord() "function-type interface" for the
-  /// Bellman-Ford algorithm, which is convenient in the simplier cases and
-  /// it can be used easier.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// The default type is \ref ListDigraph.
-  /// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies
-  /// the lengths of the arcs. The default map type is
-  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref BellmanFordDefaultTraits
-  /// "BellmanFordDefaultTraits<GR, LEN>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
-#else
-  template <typename GR=ListDigraph,
-            typename LEN=typename GR::template ArcMap<int>,
-            typename TR=BellmanFordDefaultTraits<GR,LEN> >
-#endif
-  class BellmanFord {
-  public:
-
-    ///The type of the underlying digraph.
-    typedef typename TR::Digraph Digraph;
-
-    /// \brief The type of the arc lengths.
-    typedef typename TR::LengthMap::Value Value;
-    /// \brief The type of the map that stores the arc lengths.
-    typedef typename TR::LengthMap LengthMap;
-    /// \brief The type of the map that stores the last
-    /// arcs of the shortest paths.
-    typedef typename TR::PredMap PredMap;
-    /// \brief The type of the map that stores the distances of the nodes.
-    typedef typename TR::DistMap DistMap;
-    /// The type of the paths.
-    typedef PredMapPath<Digraph, PredMap> Path;
-    ///\brief The \ref lemon::BellmanFordDefaultOperationTraits
-    /// "operation traits class" of the algorithm.
-    typedef typename TR::OperationTraits OperationTraits;
-
-    ///\brief The \ref lemon::BellmanFordDefaultTraits "traits class"
-    ///of the algorithm.
-    typedef TR Traits;
-
-  private:
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::OutArcIt OutArcIt;
-
-    // Pointer to the underlying digraph.
-    const Digraph *_gr;
-    // Pointer to the length map
-    const LengthMap *_length;
-    // Pointer to the map of predecessors arcs.
-    PredMap *_pred;
-    // Indicates if _pred is locally allocated (true) or not.
-    bool _local_pred;
-    // Pointer to the map of distances.
-    DistMap *_dist;
-    // Indicates if _dist is locally allocated (true) or not.
-    bool _local_dist;
-
-    typedef typename Digraph::template NodeMap<bool> MaskMap;
-    MaskMap *_mask;
-
-    std::vector<Node> _process;
-
-    // Creates the maps if necessary.
-    void create_maps() {
-      if(!_pred) {
-        _local_pred = true;
-        _pred = Traits::createPredMap(*_gr);
-      }
-      if(!_dist) {
-        _local_dist = true;
-        _dist = Traits::createDistMap(*_gr);
-      }
-      if(!_mask) {
-        _mask = new MaskMap(*_gr);
-      }
-    }
-
-  public :
-
-    typedef BellmanFord Create;
-
-    /// \name Named Template Parameters
-
-    ///@{
-
-    template <class T>
-    struct SetPredMapTraits : public Traits {
-      typedef T PredMap;
-      static PredMap *createPredMap(const Digraph&) {
-        LEMON_ASSERT(false, "PredMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c PredMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c PredMap type.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    template <class T>
-    struct SetPredMap
-      : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
-      typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct SetDistMapTraits : public Traits {
-      typedef T DistMap;
-      static DistMap *createDistMap(const Digraph&) {
-        LEMON_ASSERT(false, "DistMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c DistMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c DistMap type.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    template <class T>
-    struct SetDistMap
-      : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
-      typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct SetOperationTraitsTraits : public Traits {
-      typedef T OperationTraits;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c OperationTraits type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c OperationTraits type.
-    /// For more information, see \ref BellmanFordDefaultOperationTraits.
-    template <class T>
-    struct SetOperationTraits
-      : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {
-      typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> >
-      Create;
-    };
-
-    ///@}
-
-  protected:
-
-    BellmanFord() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param g The digraph the algorithm runs on.
-    /// \param length The length map used by the algorithm.
-    BellmanFord(const Digraph& g, const LengthMap& length) :
-      _gr(&g), _length(&length),
-      _pred(0), _local_pred(false),
-      _dist(0), _local_dist(false), _mask(0) {}
-
-    ///Destructor.
-    ~BellmanFord() {
-      if(_local_pred) delete _pred;
-      if(_local_dist) delete _dist;
-      if(_mask) delete _mask;
-    }
-
-    /// \brief Sets the length map.
-    ///
-    /// Sets the length map.
-    /// \return <tt>(*this)</tt>
-    BellmanFord &lengthMap(const LengthMap &map) {
-      _length = &map;
-      return *this;
-    }
-
-    /// \brief Sets the map that stores the predecessor arcs.
-    ///
-    /// Sets the map that stores the predecessor arcs.
-    /// If you don't use this function before calling \ref run()
-    /// or \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    BellmanFord &predMap(PredMap &map) {
-      if(_local_pred) {
-        delete _pred;
-        _local_pred=false;
-      }
-      _pred = &map;
-      return *this;
-    }
-
-    /// \brief Sets the map that stores the distances of the nodes.
-    ///
-    /// Sets the map that stores the distances of the nodes calculated
-    /// by the algorithm.
-    /// If you don't use this function before calling \ref run()
-    /// or \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    BellmanFord &distMap(DistMap &map) {
-      if(_local_dist) {
-        delete _dist;
-        _local_dist=false;
-      }
-      _dist = &map;
-      return *this;
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the Bellman-Ford algorithm is to use
-    /// one of the member functions called \ref run().\n
-    /// If you need better control on the execution, you have to call
-    /// \ref init() first, then you can add several source nodes
-    /// with \ref addSource(). Finally the actual path computation can be
-    /// performed with \ref start(), \ref checkedStart() or
-    /// \ref limitedStart().
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures. The optional parameter
-    /// is the initial distance of each node.
-    void init(const Value value = OperationTraits::infinity()) {
-      create_maps();
-      for (NodeIt it(*_gr); it != INVALID; ++it) {
-        _pred->set(it, INVALID);
-        _dist->set(it, value);
-      }
-      _process.clear();
-      if (OperationTraits::less(value, OperationTraits::infinity())) {
-        for (NodeIt it(*_gr); it != INVALID; ++it) {
-          _process.push_back(it);
-          _mask->set(it, true);
-        }
-      } else {
-        for (NodeIt it(*_gr); it != INVALID; ++it) {
-          _mask->set(it, false);
-        }
-      }
-    }
-
-    /// \brief Adds a new source node.
-    ///
-    /// This function adds a new source node. The optional second parameter
-    /// is the initial distance of the node.
-    void addSource(Node source, Value dst = OperationTraits::zero()) {
-      _dist->set(source, dst);
-      if (!(*_mask)[source]) {
-        _process.push_back(source);
-        _mask->set(source, true);
-      }
-    }
-
-    /// \brief Executes one round from the Bellman-Ford algorithm.
-    ///
-    /// If the algoritm calculated the distances in the previous round
-    /// exactly for the paths of at most \c k arcs, then this function
-    /// will calculate the distances exactly for the paths of at most
-    /// <tt>k+1</tt> arcs. Performing \c k iterations using this function
-    /// calculates the shortest path distances exactly for the paths
-    /// consisting of at most \c k arcs.
-    ///
-    /// \warning The paths with limited arc number cannot be retrieved
-    /// easily with \ref path() or \ref predArc() functions. If you also
-    /// need the shortest paths and not only the distances, you should
-    /// store the \ref predMap() "predecessor map" after each iteration
-    /// and build the path manually.
-    ///
-    /// \return \c true when the algorithm have not found more shorter
-    /// paths.
-    ///
-    /// \see ActiveIt
-    bool processNextRound() {
-      for (int i = 0; i < int(_process.size()); ++i) {
-        _mask->set(_process[i], false);
-      }
-      std::vector<Node> nextProcess;
-      std::vector<Value> values(_process.size());
-      for (int i = 0; i < int(_process.size()); ++i) {
-        values[i] = (*_dist)[_process[i]];
-      }
-      for (int i = 0; i < int(_process.size()); ++i) {
-        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
-          Node target = _gr->target(it);
-          Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
-          if (OperationTraits::less(relaxed, (*_dist)[target])) {
-            _pred->set(target, it);
-            _dist->set(target, relaxed);
-            if (!(*_mask)[target]) {
-              _mask->set(target, true);
-              nextProcess.push_back(target);
-            }
-          }
-        }
-      }
-      _process.swap(nextProcess);
-      return _process.empty();
-    }
-
-    /// \brief Executes one weak round from the Bellman-Ford algorithm.
-    ///
-    /// If the algorithm calculated the distances in the previous round
-    /// at least for the paths of at most \c k arcs, then this function
-    /// will calculate the distances at least for the paths of at most
-    /// <tt>k+1</tt> arcs.
-    /// This function does not make it possible to calculate the shortest
-    /// path distances exactly for paths consisting of at most \c k arcs,
-    /// this is why it is called weak round.
-    ///
-    /// \return \c true when the algorithm have not found more shorter
-    /// paths.
-    ///
-    /// \see ActiveIt
-    bool processNextWeakRound() {
-      for (int i = 0; i < int(_process.size()); ++i) {
-        _mask->set(_process[i], false);
-      }
-      std::vector<Node> nextProcess;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
-          Node target = _gr->target(it);
-          Value relaxed =
-            OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
-          if (OperationTraits::less(relaxed, (*_dist)[target])) {
-            _pred->set(target, it);
-            _dist->set(target, relaxed);
-            if (!(*_mask)[target]) {
-              _mask->set(target, true);
-              nextProcess.push_back(target);
-            }
-          }
-        }
-      }
-      _process.swap(nextProcess);
-      return _process.empty();
-    }
-
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the root node(s)
-    /// in order to compute the shortest path to each node.
-    ///
-    /// The algorithm computes
-    /// - the shortest path tree (forest),
-    /// - the distance of each node from the root(s).
-    ///
-    /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
-    void start() {
-      int num = countNodes(*_gr) - 1;
-      for (int i = 0; i < num; ++i) {
-        if (processNextWeakRound()) break;
-      }
-    }
-
-    /// \brief Executes the algorithm and checks the negative cycles.
-    ///
-    /// Executes the algorithm and checks the negative cycles.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the root node(s)
-    /// in order to compute the shortest path to each node and also checks
-    /// if the digraph contains cycles with negative total length.
-    ///
-    /// The algorithm computes
-    /// - the shortest path tree (forest),
-    /// - the distance of each node from the root(s).
-    ///
-    /// \return \c false if there is a negative cycle in the digraph.
-    ///
-    /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
-    bool checkedStart() {
-      int num = countNodes(*_gr);
-      for (int i = 0; i < num; ++i) {
-        if (processNextWeakRound()) return true;
-      }
-      return _process.empty();
-    }
-
-    /// \brief Executes the algorithm with arc number limit.
-    ///
-    /// Executes the algorithm with arc number limit.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the root node(s)
-    /// in order to compute the shortest path distance for each node
-    /// using only the paths consisting of at most \c num arcs.
-    ///
-    /// The algorithm computes
-    /// - the limited distance of each node from the root(s),
-    /// - the predecessor arc for each node.
-    ///
-    /// \warning The paths with limited arc number cannot be retrieved
-    /// easily with \ref path() or \ref predArc() functions. If you also
-    /// need the shortest paths and not only the distances, you should
-    /// store the \ref predMap() "predecessor map" after each iteration
-    /// and build the path manually.
-    ///
-    /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
-    void limitedStart(int num) {
-      for (int i = 0; i < num; ++i) {
-        if (processNextRound()) break;
-      }
-    }
-
-    /// \brief Runs the algorithm from the given root node.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the given root
-    /// node \c s in order to compute the shortest path to each node.
-    ///
-    /// The algorithm computes
-    /// - the shortest path tree (forest),
-    /// - the distance of each node from the root(s).
-    ///
-    /// \note bf.run(s) is just a shortcut of the following code.
-    /// \code
-    ///   bf.init();
-    ///   bf.addSource(s);
-    ///   bf.start();
-    /// \endcode
-    void run(Node s) {
-      init();
-      addSource(s);
-      start();
-    }
-
-    /// \brief Runs the algorithm from the given root node with arc
-    /// number limit.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the given root
-    /// node \c s in order to compute the shortest path distance for each
-    /// node using only the paths consisting of at most \c num arcs.
-    ///
-    /// The algorithm computes
-    /// - the limited distance of each node from the root(s),
-    /// - the predecessor arc for each node.
-    ///
-    /// \warning The paths with limited arc number cannot be retrieved
-    /// easily with \ref path() or \ref predArc() functions. If you also
-    /// need the shortest paths and not only the distances, you should
-    /// store the \ref predMap() "predecessor map" after each iteration
-    /// and build the path manually.
-    ///
-    /// \note bf.run(s, num) is just a shortcut of the following code.
-    /// \code
-    ///   bf.init();
-    ///   bf.addSource(s);
-    ///   bf.limitedStart(num);
-    /// \endcode
-    void run(Node s, int num) {
-      init();
-      addSource(s);
-      limitedStart(num);
-    }
-
-    ///@}
-
-    /// \brief LEMON iterator for getting the active nodes.
-    ///
-    /// This class provides a common style LEMON iterator that traverses
-    /// the active nodes of the Bellman-Ford algorithm after the last
-    /// phase. These nodes should be checked in the next phase to
-    /// find augmenting arcs outgoing from them.
-    class ActiveIt {
-    public:
-
-      /// \brief Constructor.
-      ///
-      /// Constructor for getting the active nodes of the given BellmanFord
-      /// instance.
-      ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
-      {
-        _index = _algorithm->_process.size() - 1;
-      }
-
-      /// \brief Invalid constructor.
-      ///
-      /// Invalid constructor.
-      ActiveIt(Invalid) : _algorithm(0), _index(-1) {}
-
-      /// \brief Conversion to \c Node.
-      ///
-      /// Conversion to \c Node.
-      operator Node() const {
-        return _index >= 0 ? _algorithm->_process[_index] : INVALID;
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ActiveIt& operator++() {
-        --_index;
-        return *this;
-      }
-
-      bool operator==(const ActiveIt& it) const {
-        return static_cast<Node>(*this) == static_cast<Node>(it);
-      }
-      bool operator!=(const ActiveIt& it) const {
-        return static_cast<Node>(*this) != static_cast<Node>(it);
-      }
-      bool operator<(const ActiveIt& it) const {
-        return static_cast<Node>(*this) < static_cast<Node>(it);
-      }
-
-    private:
-      const BellmanFord* _algorithm;
-      int _index;
-    };
-
-    /// \name Query Functions
-    /// The result of the Bellman-Ford algorithm can be obtained using these
-    /// functions.\n
-    /// Either \ref run() or \ref init() should be called before using them.
-
-    ///@{
-
-    /// \brief The shortest path to the given node.
-    ///
-    /// Gives back the shortest path to the given node from the root(s).
-    ///
-    /// \warning \c t should be reached from the root(s).
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Path path(Node t) const
-    {
-      return Path(*_gr, *_pred, t);
-    }
-
-    /// \brief The distance of the given node from the root(s).
-    ///
-    /// Returns the distance of the given node from the root(s).
-    ///
-    /// \warning If node \c v is not reached from the root(s), then
-    /// the return value of this function is undefined.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value dist(Node v) const { return (*_dist)[v]; }
-
-    /// \brief Returns the 'previous arc' of the shortest path tree for
-    /// the given node.
-    ///
-    /// This function returns the 'previous arc' of the shortest path
-    /// tree for node \c v, i.e. it returns the last arc of a
-    /// shortest path from a root to \c v. It is \c INVALID if \c v
-    /// is not reached from the root(s) or if \c v is a root.
-    ///
-    /// The shortest path tree used here is equal to the shortest path
-    /// tree used in \ref predNode() and \ref predMap().
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Arc predArc(Node v) const { return (*_pred)[v]; }
-
-    /// \brief Returns the 'previous node' of the shortest path tree for
-    /// the given node.
-    ///
-    /// This function returns the 'previous node' of the shortest path
-    /// tree for node \c v, i.e. it returns the last but one node of
-    /// a shortest path from a root to \c v. It is \c INVALID if \c v
-    /// is not reached from the root(s) or if \c v is a root.
-    ///
-    /// The shortest path tree used here is equal to the shortest path
-    /// tree used in \ref predArc() and \ref predMap().
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Node predNode(Node v) const {
-      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
-    }
-
-    /// \brief Returns a const reference to the node map that stores the
-    /// distances of the nodes.
-    ///
-    /// Returns a const reference to the node map that stores the distances
-    /// of the nodes calculated by the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const DistMap &distMap() const { return *_dist;}
-
-    /// \brief Returns a const reference to the node map that stores the
-    /// predecessor arcs.
-    ///
-    /// Returns a const reference to the node map that stores the predecessor
-    /// arcs, which form the shortest path tree (forest).
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const PredMap &predMap() const { return *_pred; }
-
-    /// \brief Checks if a node is reached from the root(s).
-    ///
-    /// Returns \c true if \c v is reached from the root(s).
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    bool reached(Node v) const {
-      return (*_dist)[v] != OperationTraits::infinity();
-    }
-
-    /// \brief Gives back a negative cycle.
-    ///
-    /// This function gives back a directed cycle with negative total
-    /// length if the algorithm has already found one.
-    /// Otherwise it gives back an empty path.
-    lemon::Path<Digraph> negativeCycle() const {
-      typename Digraph::template NodeMap<int> state(*_gr, -1);
-      lemon::Path<Digraph> cycle;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        if (state[_process[i]] != -1) continue;
-        for (Node v = _process[i]; (*_pred)[v] != INVALID;
-             v = _gr->source((*_pred)[v])) {
-          if (state[v] == i) {
-            cycle.addFront((*_pred)[v]);
-            for (Node u = _gr->source((*_pred)[v]); u != v;
-                 u = _gr->source((*_pred)[u])) {
-              cycle.addFront((*_pred)[u]);
-            }
-            return cycle;
-          }
-          else if (state[v] >= 0) {
-            break;
-          }
-          state[v] = i;
-        }
-      }
-      return cycle;
-    }
-
-    ///@}
-  };
-
-  /// \brief Default traits class of bellmanFord() function.
-  ///
-  /// Default traits class of bellmanFord() function.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
-  template <typename GR, typename LEN>
-  struct BellmanFordWizardDefaultTraits {
-    /// The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \brief The type of the map that stores the arc lengths.
-    ///
-    /// The type of the map that stores the arc lengths.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LEN LengthMap;
-
-    /// The type of the arc lengths.
-    typedef typename LEN::Value Value;
-
-    /// \brief Operation traits for Bellman-Ford algorithm.
-    ///
-    /// It defines the used operations and the infinity value for the
-    /// given \c Value type.
-    /// \see BellmanFordDefaultOperationTraits
-    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
-
-    /// \brief The type of the map that stores the last
-    /// arcs of the shortest paths.
-    ///
-    /// The type of the map that stores the last arcs of the shortest paths.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
-
-    /// \brief Instantiates a \c PredMap.
-    ///
-    /// This function instantiates a \ref PredMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref PredMap.
-    static PredMap *createPredMap(const GR &g) {
-      return new PredMap(g);
-    }
-
-    /// \brief The type of the map that stores the distances of the nodes.
-    ///
-    /// The type of the map that stores the distances of the nodes.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<Value> DistMap;
-
-    /// \brief Instantiates a \c DistMap.
-    ///
-    /// This function instantiates a \ref DistMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref DistMap.
-    static DistMap *createDistMap(const GR &g) {
-      return new DistMap(g);
-    }
-
-    ///The type of the shortest paths.
-
-    ///The type of the shortest paths.
-    ///It must meet the \ref concepts::Path "Path" concept.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  /// \brief Default traits class used by BellmanFordWizard.
-  ///
-  /// Default traits class used by BellmanFordWizard.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
-  template <typename GR, typename LEN>
-  class BellmanFordWizardBase
-    : public BellmanFordWizardDefaultTraits<GR, LEN> {
-
-    typedef BellmanFordWizardDefaultTraits<GR, LEN> Base;
-  protected:
-    // Type of the nodes in the digraph.
-    typedef typename Base::Digraph::Node Node;
-
-    // Pointer to the underlying digraph.
-    void *_graph;
-    // Pointer to the length map
-    void *_length;
-    // Pointer to the map of predecessors arcs.
-    void *_pred;
-    // Pointer to the map of distances.
-    void *_dist;
-    //Pointer to the shortest path to the target node.
-    void *_path;
-    //Pointer to the distance of the target node.
-    void *_di;
-
-    public:
-    /// Constructor.
-
-    /// This constructor does not require parameters, it initiates
-    /// all of the attributes to default values \c 0.
-    BellmanFordWizardBase() :
-      _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {}
-
-    /// Constructor.
-
-    /// This constructor requires two parameters,
-    /// others are initiated to \c 0.
-    /// \param gr The digraph the algorithm runs on.
-    /// \param len The length map.
-    BellmanFordWizardBase(const GR& gr,
-                          const LEN& len) :
-      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))),
-      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))),
-      _pred(0), _dist(0), _path(0), _di(0) {}
-
-  };
-
-  /// \brief Auxiliary class for the function-type interface of the
-  /// \ref BellmanFord "Bellman-Ford" algorithm.
-  ///
-  /// This auxiliary class is created to implement the
-  /// \ref bellmanFord() "function-type interface" of the
-  /// \ref BellmanFord "Bellman-Ford" algorithm.
-  /// It does not have own \ref run() method, it uses the
-  /// functions and features of the plain \ref BellmanFord.
-  ///
-  /// This class should only be used through the \ref bellmanFord()
-  /// function, which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
-  template<class TR>
-  class BellmanFordWizard : public TR {
-    typedef TR Base;
-
-    typedef typename TR::Digraph Digraph;
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::OutArcIt ArcIt;
-
-    typedef typename TR::LengthMap LengthMap;
-    typedef typename LengthMap::Value Value;
-    typedef typename TR::PredMap PredMap;
-    typedef typename TR::DistMap DistMap;
-    typedef typename TR::Path Path;
-
-  public:
-    /// Constructor.
-    BellmanFordWizard() : TR() {}
-
-    /// \brief Constructor that requires parameters.
-    ///
-    /// Constructor that requires parameters.
-    /// These parameters will be the default values for the traits class.
-    /// \param gr The digraph the algorithm runs on.
-    /// \param len The length map.
-    BellmanFordWizard(const Digraph& gr, const LengthMap& len)
-      : TR(gr, len) {}
-
-    /// \brief Copy constructor
-    BellmanFordWizard(const TR &b) : TR(b) {}
-
-    ~BellmanFordWizard() {}
-
-    /// \brief Runs the Bellman-Ford algorithm from the given source node.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the given source
-    /// node in order to compute the shortest path to each node.
-    void run(Node s) {
-      BellmanFord<Digraph,LengthMap,TR>
-        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
-           *reinterpret_cast<const LengthMap*>(Base::_length));
-      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
-      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-      bf.run(s);
-    }
-
-    /// \brief Runs the Bellman-Ford algorithm to find the shortest path
-    /// between \c s and \c t.
-    ///
-    /// This method runs the Bellman-Ford algorithm from node \c s
-    /// in order to compute the shortest path to node \c t.
-    /// Actually, it computes the shortest path to each node, but using
-    /// this function you can retrieve the distance and the shortest path
-    /// for a single target node easier.
-    ///
-    /// \return \c true if \c t is reachable form \c s.
-    bool run(Node s, Node t) {
-      BellmanFord<Digraph,LengthMap,TR>
-        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
-           *reinterpret_cast<const LengthMap*>(Base::_length));
-      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
-      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-      bf.run(s);
-      if (Base::_path) *reinterpret_cast<Path*>(Base::_path) = bf.path(t);
-      if (Base::_di) *reinterpret_cast<Value*>(Base::_di) = bf.dist(t);
-      return bf.reached(t);
-    }
-
-    template<class T>
-    struct SetPredMapBase : public Base {
-      typedef T PredMap;
-      static PredMap *createPredMap(const Digraph &) { return 0; };
-      SetPredMapBase(const TR &b) : TR(b) {}
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// the predecessor map.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// the map that stores the predecessor arcs of the nodes.
-    template<class T>
-    BellmanFordWizard<SetPredMapBase<T> > predMap(const T &t) {
-      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BellmanFordWizard<SetPredMapBase<T> >(*this);
-    }
-
-    template<class T>
-    struct SetDistMapBase : public Base {
-      typedef T DistMap;
-      static DistMap *createDistMap(const Digraph &) { return 0; };
-      SetDistMapBase(const TR &b) : TR(b) {}
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// the distance map.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// the map that stores the distances of the nodes calculated
-    /// by the algorithm.
-    template<class T>
-    BellmanFordWizard<SetDistMapBase<T> > distMap(const T &t) {
-      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BellmanFordWizard<SetDistMapBase<T> >(*this);
-    }
-
-    template<class T>
-    struct SetPathBase : public Base {
-      typedef T Path;
-      SetPathBase(const TR &b) : TR(b) {}
-    };
-
-    /// \brief \ref named-func-param "Named parameter" for getting
-    /// the shortest path to the target node.
-    ///
-    /// \ref named-func-param "Named parameter" for getting
-    /// the shortest path to the target node.
-    template<class T>
-    BellmanFordWizard<SetPathBase<T> > path(const T &t)
-    {
-      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BellmanFordWizard<SetPathBase<T> >(*this);
-    }
-
-    /// \brief \ref named-func-param "Named parameter" for getting
-    /// the distance of the target node.
-    ///
-    /// \ref named-func-param "Named parameter" for getting
-    /// the distance of the target node.
-    BellmanFordWizard dist(const Value &d)
-    {
-      Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
-      return *this;
-    }
-
-  };
-
-  /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
-  /// algorithm.
-  ///
-  /// \ingroup shortest_path
-  /// Function type interface for the \ref BellmanFord "Bellman-Ford"
-  /// algorithm.
-  ///
-  /// This function also has several \ref named-templ-func-param
-  /// "named parameters", they are declared as the members of class
-  /// \ref BellmanFordWizard.
-  /// The following examples show how to use these parameters.
-  /// \code
-  ///   // Compute shortest path from node s to each node
-  ///   bellmanFord(g,length).predMap(preds).distMap(dists).run(s);
-  ///
-  ///   // Compute shortest path from s to t
-  ///   bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t);
-  /// \endcode
-  /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
-  /// to the end of the parameter list.
-  /// \sa BellmanFordWizard
-  /// \sa BellmanFord
-  template<typename GR, typename LEN>
-  BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
-  bellmanFord(const GR& digraph,
-              const LEN& length)
-  {
-    return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);
-  }
-
-} //END OF NAMESPACE LEMON
-
-#endif
-
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 1250)
+++ lemon/bfs.h	(revision 1125)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -48,5 +48,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -63,6 +63,5 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -83,6 +82,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -99,5 +97,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
@@ -123,9 +121,4 @@
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref BfsDefaultTraits
-  ///"BfsDefaultTraits<GR>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
@@ -153,5 +146,5 @@
     typedef PredMapPath<Digraph, PredMap> Path;
 
-    ///The \ref lemon::BfsDefaultTraits "traits class" of the algorithm.
+    ///The \ref BfsDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 
@@ -233,5 +226,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
@@ -253,5 +246,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
@@ -273,6 +266,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
@@ -294,5 +286,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
@@ -422,6 +414,6 @@
     ///The simplest way to execute the BFS algorithm is to use one of the
     ///member functions called \ref run(Node) "run()".\n
-    ///If you need better control on the execution, you have to call
-    ///\ref init() first, then you can add several source nodes with
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), then you can add several source nodes with
     ///\ref addSource(). Finally the actual path computation can be
     ///performed with one of the \ref start() functions.
@@ -709,6 +701,10 @@
     ///Runs the algorithm to visit all nodes in the digraph.
 
-    ///This method runs the %BFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs the %BFS algorithm in order to
+    ///compute the shortest path to each node.
+    ///
+    ///The algorithm computes
+    ///- the shortest path tree (forest),
+    ///- the distance of each node from the root(s).
     ///
     ///\note <tt>b.run(s)</tt> is just a shortcut of the following code.
@@ -742,7 +738,7 @@
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns the shortest path to the given node from the root(s).
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -752,7 +748,7 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -763,7 +759,6 @@
     int dist(Node v) const { return (*_dist)[v]; }
 
-    ///\brief Returns the 'previous arc' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous arc' of the shortest path tree for a node.
+
     ///This function returns the 'previous arc' of the shortest path
     ///tree for the node \c v, i.e. it returns the last arc of a
@@ -772,5 +767,5 @@
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predNode() and \ref predMap().
+    ///tree used in \ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -778,14 +773,13 @@
     Arc predArc(Node v) const { return (*_pred)[v];}
 
-    ///\brief Returns the 'previous node' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous node' of the shortest path tree for a node.
+
     ///This function returns the 'previous node' of the shortest path
     ///tree for the node \c v, i.e. it returns the last but one node
-    ///of a shortest path from a root to \c v. It is \c INVALID
+    ///from a shortest path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predArc() and \ref predMap().
+    ///tree used in \ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -808,5 +802,5 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
+    ///arcs, which form the shortest path tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -814,5 +808,5 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -840,5 +834,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -855,6 +849,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
@@ -875,6 +869,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -891,5 +884,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
@@ -906,5 +899,5 @@
 
     ///The type of the shortest paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -912,6 +905,10 @@
   /// Default traits class used by BfsWizard
 
-  /// Default traits class used by BfsWizard.
-  /// \tparam GR The type of the digraph.
+  /// To make it easier to use Bfs algorithm
+  /// we have created a wizard class.
+  /// This \ref BfsWizard class needs default traits,
+  /// as well as the \ref Bfs class.
+  /// The \ref BfsWizardBase is a class to be the default traits of the
+  /// \ref BfsWizard class.
   template<class GR>
   class BfsWizardBase : public BfsWizardDefaultTraits<GR>
@@ -941,5 +938,5 @@
     /// Constructor.
 
-    /// This constructor does not require parameters, it initiates
+    /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to \c 0.
     BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -966,7 +963,4 @@
   /// This class should only be used through the \ref bfs() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class BfsWizard : public TR
@@ -974,4 +968,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -981,8 +976,14 @@
     typedef typename Digraph::OutArcIt OutArcIt;
 
+    ///\brief The type of the map that stores the predecessor
+    ///arcs of the shortest paths.
     typedef typename TR::PredMap PredMap;
+    ///\brief The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
+    ///\brief The type of the map that indicates which nodes are reached.
     typedef typename TR::ReachedMap ReachedMap;
+    ///\brief The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
+    ///The type of the shortest paths
     typedef typename TR::Path Path;
 
@@ -1054,6 +1055,6 @@
     ///Runs BFS algorithm to visit all nodes in the digraph.
 
-    ///This method runs BFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs BFS algorithm in order to compute
+    ///the shortest path to each node.
     void run()
     {
@@ -1067,10 +1068,9 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the predecessor map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the predecessor arcs of the nodes.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     BfsWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1086,10 +1086,9 @@
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the reached map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are reached.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
     template<class T>
     BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
@@ -1105,11 +1104,9 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the distance map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the distances of the nodes calculated
-    ///by the algorithm.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     BfsWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1125,10 +1122,9 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-func-param "Named parameter" for setting
-    ///the processed map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are processed.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1270,6 +1266,5 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1309,9 +1304,9 @@
   /// does not observe the BFS events. If you want to observe the BFS
   /// events, you should implement your own visitor class.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref BfsVisitDefaultTraits
-  /// "BfsVisitDefaultTraits<GR>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// \tparam TR Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
+  /// See \ref BfsVisitDefaultTraits for the documentation of
+  /// a BFS visit traits class.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
@@ -1432,6 +1427,6 @@
     /// The simplest way to execute the BFS algorithm is to use one of the
     /// member functions called \ref run(Node) "run()".\n
-    /// If you need better control on the execution, you have to call
-    /// \ref init() first, then you can add several source nodes with
+    /// If you need more control on the execution, first you have to call
+    /// \ref init(), then you can add several source nodes with
     /// \ref addSource(). Finally the actual path computation can be
     /// performed with one of the \ref start() functions.
@@ -1705,6 +1700,10 @@
     /// \brief Runs the algorithm to visit all nodes in the digraph.
     ///
-    /// This method runs the %BFS algorithm in order to visit all nodes
-    /// in the digraph.
+    /// This method runs the %BFS algorithm in order to
+    /// compute the shortest path to each node.
+    ///
+    /// The algorithm computes
+    /// - the shortest path tree (forest),
+    /// - the distance of each node from the root(s).
     ///
     /// \note <tt>b.run(s)</tt> is just a shortcut of the following code.
@@ -1738,5 +1737,5 @@
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
+    /// \brief Checks if a node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).
Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 758)
+++ lemon/bin_heap.h	(revision 730)
@@ -20,7 +20,7 @@
 #define LEMON_BIN_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Binary heap implementation.
+///\brief Binary Heap implementation.
 
 #include <vector>
@@ -30,39 +30,43 @@
 namespace lemon {
 
-  /// \ingroup heaps
-  ///
-  /// \brief Binary heap data structure.
-  ///
-  /// This class implements the \e binary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
+  ///\ingroup auxdat
+  ///
+  ///\brief A Binary Heap implementation.
+  ///
+  ///This class implements the \e binary \e heap data structure.
+  ///
+  ///A \e heap is a data structure for storing items with specified values
+  ///called \e priorities in such a way that finding the item with minimum
+  ///priority is efficient. \c CMP specifies the ordering of the priorities.
+  ///In a heap one can change the priority of an item, add or erase an
+  ///item, etc.
+  ///
+  ///\tparam PR Type of the priority of the items.
+  ///\tparam IM A read and writable item map with int values, used internally
+  ///to handle the cross references.
+  ///\tparam CMP A functor class for the ordering of the priorities.
+  ///The default is \c std::less<PR>.
+  ///
+  ///\sa FibHeap
+  ///\sa Dijkstra
   template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
   class BinHeap {
+
   public:
-
-    /// Type of the item-int map.
+    ///\e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
+    ///\e
     typedef PR Prio;
-    /// Type of the items stored in the heap.
+    ///\e
     typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
+    ///\e
     typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
+    ///\e
     typedef CMP Compare;
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -81,41 +85,40 @@
 
   public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// must be \c PRE_HEAP (<tt>-1</tt>) for every item.
     explicit BinHeap(ItemIntMap &map) : _iim(map) {}
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    ///
+    /// \param comp The comparator function object.
     BinHeap(ItemIntMap &map, const Compare &comp)
       : _iim(map), _comp(comp) {}
 
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
     int size() const { return _data.size(); }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _data.empty(); }
 
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference map.
+    /// If you want to reuse what is not surely empty you should first clear
+    /// the heap and after that you should set the cross reference map for
+    /// each item to \c PRE_HEAP.
     void clear() {
       _data.clear();
@@ -125,10 +128,10 @@
     static int parent(int i) { return (i-1)/2; }
 
-    static int secondChild(int i) { return 2*i+2; }
+    static int second_child(int i) { return 2*i+2; }
     bool less(const Pair &p1, const Pair &p2) const {
       return _comp(p1.second, p2.second);
     }
 
-    int bubbleUp(int hole, Pair p) {
+    int bubble_up(int hole, Pair p) {
       int par = parent(hole);
       while( hole>0 && less(p,_data[par]) ) {
@@ -141,6 +144,6 @@
     }
 
-    int bubbleDown(int hole, Pair p, int length) {
-      int child = secondChild(hole);
+    int bubble_down(int hole, Pair p, int length) {
+      int child = second_child(hole);
       while(child < length) {
         if( less(_data[child-1], _data[child]) ) {
@@ -151,5 +154,5 @@
         move(_data[child], hole);
         hole = child;
-        child = secondChild(hole);
+        child = second_child(hole);
       }
       child--;
@@ -169,45 +172,42 @@
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \c p.first to the heap with priority \c p.second.
     /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair &p) {
       int n = _data.size();
       _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+      bubble_up(n, p);
+    }
+
+    /// \brief Insert an item into the heap with the given heap.
+    ///
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority relative to \c Compare.
+    ///
+    /// This method returns the item with minimum priority relative to \c
+    /// Compare.
+    /// \pre The heap must be nonempty.
     Item top() const {
       return _data[0].first;
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority relative to \c Compare.
+    ///
+    /// It returns the minimum priority relative to \c Compare.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       return _data[0].second;
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority relative to \c Compare.
+    ///
+    /// This method deletes the item with minimum priority relative to \c
+    /// Compare from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -215,15 +215,14 @@
       _iim.set(_data[0].first, POST_HEAP);
       if (n > 0) {
-        bubbleDown(0, _data[n], n);
+        bubble_down(0, _data[n], n);
       }
       _data.pop_back();
     }
 
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap.
+    /// \param i The item to erase.
+    /// \pre The item should be in the heap.
     void erase(const Item &i) {
       int h = _iim[i];
@@ -231,6 +230,6 @@
       _iim.set(_data[h].first, POST_HEAP);
       if( h < n ) {
-        if ( bubbleUp(h, _data[n]) == h) {
-          bubbleDown(h, _data[n], n);
+        if ( bubble_up(h, _data[n]) == h) {
+          bubble_down(h, _data[n], n);
         }
       }
@@ -238,9 +237,10 @@
     }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
+
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \param i The item.
+    /// \pre \c i must be in the heap.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
@@ -248,10 +248,9 @@
     }
 
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
     /// \param i The item.
     /// \param p The priority.
@@ -262,40 +261,42 @@
       }
       else if( _comp(p, _data[idx].second) ) {
-        bubbleUp(idx, Pair(i,p));
+        bubble_up(idx, Pair(i,p));
       }
       else {
-        bubbleDown(idx, Pair(i,p), _data.size());
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+        bubble_down(idx, Pair(i,p), _data.size());
+      }
+    }
+
+    /// \brief Decreases the priority of \c i to \c p.
+    ///
+    /// This method decreases the priority of item \c i to \c p.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
+    /// \pre \c i must be stored in the heap with priority at least \c
+    /// p relative to \c Compare.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+      bubble_up(idx, Pair(i,p));
+    }
+
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
+      bubble_down(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
@@ -306,9 +307,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -327,11 +328,10 @@
     }
 
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
+    /// \brief Replaces an item in the heap.
+    ///
+    /// The \c i item is replaced with \c j item. The \c i item should
+    /// be in the heap, while the \c j should be out of the heap. The
+    /// \c i item will out of the heap and \c j will be in the heap
+    /// with the same prioriority as prevoiusly the \c i item.
     void replace(const Item& i, const Item& j) {
       int idx = _iim[i];
Index: lemon/binomial_heap.h
===================================================================
--- lemon/binomial_heap.h	(revision 956)
+++ 	(revision )
@@ -1,445 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BINOMIAL_HEAP_H
-#define LEMON_BINOMIAL_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Binomial Heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-#include <lemon/math.h>
-#include <lemon/counter.h>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Binomial heap data structure.
-  ///
-  /// This class implements the \e binomial \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The methods \ref increase() and \ref erase() are not efficient
-  /// in a binomial heap. In case of many calls of these operations,
-  /// it is better to use other heap structure, e.g. \ref BinHeap
-  /// "binary heap".
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class BinomialHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    class Store;
-
-    std::vector<Store> _data;
-    int _min, _head;
-    ItemIntMap &_iim;
-    Compare _comp;
-    int _num_items;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit BinomialHeap(ItemIntMap &map)
-      : _min(0), _head(-1), _iim(map), _num_items(0) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    BinomialHeap(ItemIntMap &map, const Compare &comp)
-      : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _num_items; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _num_items==0; }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() {
-      _data.clear(); _min=0; _num_items=0; _head=-1;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param item The item.
-    /// \param value The priority.
-    void set (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        if ( _comp(value, _data[i].prio) ) decrease(item, value);
-        if ( _comp(_data[i].prio, value) ) increase(item, value);
-      } else push(item, value);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param item The item to insert.
-    /// \param value The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i<0 ) {
-        int s=_data.size();
-        _iim.set( item,s );
-        Store st;
-        st.name=item;
-        st.prio=value;
-        _data.push_back(st);
-        i=s;
-      }
-      else {
-        _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
-        _data[i].degree=0;
-        _data[i].in=true;
-        _data[i].prio=value;
-      }
-
-      if( 0==_num_items ) {
-        _head=i;
-        _min=i;
-      } else {
-        merge(i);
-        if( _comp(_data[i].prio, _data[_min].prio) ) _min=i;
-      }
-      ++_num_items;
-    }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[_min].name; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[_min].prio; }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    const Prio& operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      _data[_min].in=false;
-
-      int head_child=-1;
-      if ( _data[_min].child!=-1 ) {
-        int child=_data[_min].child;
-        int neighb;
-        while( child!=-1 ) {
-          neighb=_data[child].right_neighbor;
-          _data[child].parent=-1;
-          _data[child].right_neighbor=head_child;
-          head_child=child;
-          child=neighb;
-        }
-      }
-
-      if ( _data[_head].right_neighbor==-1 ) {
-        // there was only one root
-        _head=head_child;
-      }
-      else {
-        // there were more roots
-        if( _head!=_min )  { unlace(_min); }
-        else { _head=_data[_head].right_neighbor; }
-        merge(head_child);
-      }
-      _min=findMin();
-      --_num_items;
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param item The item to delete.
-    /// \pre \e item must be in the heap.
-    void erase (const Item& item) {
-      int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        decrease( item, _data[_min].prio-1 );
-        pop();
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e value.
-    void decrease (Item item, const Prio& value) {
-      int i=_iim[item];
-      int p=_data[i].parent;
-      _data[i].prio=value;
-
-      while( p!=-1 && _comp(value, _data[p].prio) ) {
-        _data[i].name=_data[p].name;
-        _data[i].prio=_data[p].prio;
-        _data[p].name=item;
-        _data[p].prio=value;
-        _iim[_data[i].name]=i;
-        i=p;
-        p=_data[p].parent;
-      }
-      _iim[item]=i;
-      if ( _comp(value, _data[_min].prio) ) _min=i;
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e value.
-    void increase (Item item, const Prio& value) {
-      erase(item);
-      push(item, value);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param item The item.
-    State state(const Item &item) const {
-      int i=_iim[item];
-      if( i>=0 ) {
-        if ( _data[i].in ) i=0;
-        else i=-2;
-      }
-      return State(i);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-      case POST_HEAP:
-      case PRE_HEAP:
-        if (state(i) == IN_HEAP) {
-          erase(i);
-        }
-        _iim[i] = st;
-        break;
-      case IN_HEAP:
-        break;
-      }
-    }
-
-  private:
-
-    // Find the minimum of the roots
-    int findMin() {
-      if( _head!=-1 ) {
-        int min_loc=_head, min_val=_data[_head].prio;
-        for( int x=_data[_head].right_neighbor; x!=-1;
-             x=_data[x].right_neighbor ) {
-          if( _comp( _data[x].prio,min_val ) ) {
-            min_val=_data[x].prio;
-            min_loc=x;
-          }
-        }
-        return min_loc;
-      }
-      else return -1;
-    }
-
-    // Merge the heap with another heap starting at the given position
-    void merge(int a) {
-      if( _head==-1 || a==-1 ) return;
-      if( _data[a].right_neighbor==-1 &&
-          _data[a].degree<=_data[_head].degree ) {
-        _data[a].right_neighbor=_head;
-        _head=a;
-      } else {
-        interleave(a);
-      }
-      if( _data[_head].right_neighbor==-1 ) return;
-
-      int x=_head;
-      int x_prev=-1, x_next=_data[x].right_neighbor;
-      while( x_next!=-1 ) {
-        if( _data[x].degree!=_data[x_next].degree ||
-            ( _data[x_next].right_neighbor!=-1 &&
-              _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
-          x_prev=x;
-          x=x_next;
-        }
-        else {
-          if( _comp(_data[x_next].prio,_data[x].prio) ) {
-            if( x_prev==-1 ) {
-              _head=x_next;
-            } else {
-              _data[x_prev].right_neighbor=x_next;
-            }
-            fuse(x,x_next);
-            x=x_next;
-          }
-          else {
-            _data[x].right_neighbor=_data[x_next].right_neighbor;
-            fuse(x_next,x);
-          }
-        }
-        x_next=_data[x].right_neighbor;
-      }
-    }
-
-    // Interleave the elements of the given list into the list of the roots
-    void interleave(int a) {
-      int p=_head, q=a;
-      int curr=_data.size();
-      _data.push_back(Store());
-
-      while( p!=-1 || q!=-1 ) {
-        if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
-          _data[curr].right_neighbor=p;
-          curr=p;
-          p=_data[p].right_neighbor;
-        }
-        else {
-          _data[curr].right_neighbor=q;
-          curr=q;
-          q=_data[q].right_neighbor;
-        }
-      }
-
-      _head=_data.back().right_neighbor;
-      _data.pop_back();
-    }
-
-    // Lace node a under node b
-    void fuse(int a, int b) {
-      _data[a].parent=b;
-      _data[a].right_neighbor=_data[b].child;
-      _data[b].child=a;
-
-      ++_data[b].degree;
-    }
-
-    // Unlace node a (if it has siblings)
-    void unlace(int a) {
-      int neighb=_data[a].right_neighbor;
-      int other=_head;
-
-      while( _data[other].right_neighbor!=a )
-        other=_data[other].right_neighbor;
-      _data[other].right_neighbor=neighb;
-    }
-
-  private:
-
-    class Store {
-      friend class BinomialHeap;
-
-      Item name;
-      int parent;
-      int right_neighbor;
-      int child;
-      int degree;
-      bool in;
-      Prio prio;
-
-      Store() : parent(-1), right_neighbor(-1), child(-1), degree(0),
-        in(true) {}
-    };
-  };
-
-} //namespace lemon
-
-#endif //LEMON_BINOMIAL_HEAP_H
-
Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 1131)
+++ lemon/bits/alteration_notifier.h	(revision 463)
@@ -24,5 +24,4 @@
 
 #include <lemon/core.h>
-#include <lemon/bits/lock.h>
 
 //\ingroup graphbits
@@ -253,5 +252,5 @@
     typedef std::list<ObserverBase*> Observers;
     Observers _observers;
-    lemon::bits::Lock _lock;
+
 
   public:
@@ -334,16 +333,12 @@
 
     void attach(ObserverBase& observer) {
-      _lock.lock();
       observer._index = _observers.insert(_observers.begin(), &observer);
       observer._notifier = this;
-      _lock.unlock();
     }
 
     void detach(ObserverBase& observer) {
-      _lock.lock();
       _observers.erase(observer._index);
       observer._index = _observers.end();
       observer._notifier = 0;
-      _lock.unlock();
     }
 
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 956)
+++ lemon/bits/array_map.h	(revision 664)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,5 +71,5 @@
 
   private:
-
+  
     // The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 956)
+++ lemon/bits/default_map.h	(revision 674)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -158,5 +158,5 @@
   public:
     typedef DefaultMap<_Graph, _Item, _Value> Map;
-
+    
     typedef typename Parent::GraphType GraphType;
     typedef typename Parent::Value Value;
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 1161)
+++ lemon/bits/edge_set_extender.h	(revision 1157)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * 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-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -64,9 +64,9 @@
     Node oppositeNode(const Node &n, const Arc &e) const {
       if (n == Parent::source(e))
-        return Parent::target(e);
+	return Parent::target(e);
       else if(n==Parent::target(e))
-        return Parent::source(e);
+	return Parent::source(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -92,5 +92,5 @@
     // Iterable extensions
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Digraph* digraph;
     public:
@@ -101,19 +101,19 @@
 
       explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Digraph& _graph, const Node& node)
-        : Node(node), digraph(&_graph) {}
-
-      NodeIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Digraph& _graph, const Node& node) 
+	: Node(node), digraph(&_graph) {}
+
+      NodeIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -124,19 +124,19 @@
 
       explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Digraph& _graph, const Arc& e) :
-        Arc(e), digraph(&_graph) { }
-
-      ArcIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Digraph& _graph, const Arc& e) : 
+	Arc(e), digraph(&_graph) { }
+
+      ArcIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -146,21 +146,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Digraph& _graph, const Arc& arc)
-        : Arc(arc), digraph(&_graph) {}
-
-      OutArcIt& operator++() {
-        digraph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
+      OutArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Digraph& _graph, const Arc& arc) 
+	: Arc(arc), digraph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	digraph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -170,15 +170,15 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Digraph& _graph, const Arc& arc) :
-        Arc(arc), digraph(&_graph) {}
-
-      InArcIt& operator++() {
-        digraph->nextIn(*this);
-        return *this;
+      InArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Digraph& _graph, const Arc& arc) : 
+	Arc(arc), digraph(&_graph) {}
+
+      InArcIt& operator++() { 
+	digraph->nextIn(*this);
+	return *this; 
       }
 
@@ -216,18 +216,18 @@
 
     // Mappable extension
-
+    
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Digraph& _g)
-        : Parent(_g) {}
-      ArcMap(const Digraph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Digraph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Digraph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -235,5 +235,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -248,5 +248,5 @@
       return arc;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -313,9 +313,9 @@
     Node oppositeNode(const Node &n, const Edge &e) const {
       if( n == Parent::u(e))
-        return Parent::v(e);
+	return Parent::v(e);
       else if( n == Parent::v(e))
-        return Parent::u(e);
+	return Parent::u(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -341,5 +341,5 @@
 
     using Parent::notifier;
-
+    
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
@@ -351,5 +351,5 @@
 
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Graph* graph;
     public:
@@ -360,19 +360,19 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node)
-        : Node(node), graph(&_graph) {}
-
-      NodeIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Graph& _graph, const Node& node) 
+	: Node(node), graph(&_graph) {}
+
+      NodeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -383,19 +383,19 @@
 
       explicit ArcIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Graph& _graph, const Arc& e) :
-        Arc(e), graph(&_graph) { }
-
-      ArcIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Graph& _graph, const Arc& e) : 
+	Arc(e), graph(&_graph) { }
+
+      ArcIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -405,21 +405,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Graph& _graph, const Arc& arc)
-        : Arc(arc), graph(&_graph) {}
-
-      OutArcIt& operator++() {
-        graph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
+      OutArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Graph& _graph, const Arc& arc) 
+	: Arc(arc), graph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	graph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -429,21 +429,21 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Graph& _graph, const Arc& arc) :
-        Arc(arc), graph(&_graph) {}
-
-      InArcIt& operator++() {
-        graph->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-
-    class EdgeIt : public Parent::Edge {
+      InArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Graph& _graph, const Arc& arc) : 
+	Arc(arc), graph(&_graph) {}
+
+      InArcIt& operator++() { 
+	graph->nextIn(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class EdgeIt : public Parent::Edge { 
       const Graph* graph;
     public:
@@ -454,13 +454,13 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) :
-        Edge(e), graph(&_graph) { }
-
-      EdgeIt& operator++() {
-        graph->next(*this);
-        return *this;
+	_graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Graph& _graph, const Edge& e) : 
+	Edge(e), graph(&_graph) { }
+
+      EdgeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
       }
 
@@ -478,15 +478,15 @@
 
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
-        _graph.firstInc(*this, direction, n);
+	_graph.firstInc(*this, direction, n);
       }
 
       IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
-        : graph(&_graph), Edge(ue) {
-        direction = (_graph.source(ue) == n);
+	: graph(&_graph), Edge(ue) {
+	direction = (_graph.source(ue) == n);
       }
 
       IncEdgeIt& operator++() {
-        graph->nextInc(*this, direction);
-        return *this;
+	graph->nextInc(*this, direction);
+	return *this; 
       }
     };
@@ -535,16 +535,16 @@
 
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Graph& _g)
-        : Parent(_g) {}
-      ArcMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Graph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -552,5 +552,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -559,17 +559,17 @@
 
     template <typename _Value>
-    class EdgeMap
+    class EdgeMap 
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 
     public:
-      explicit EdgeMap(const Graph& _g)
-        : Parent(_g) {}
-
-      EdgeMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit EdgeMap(const Graph& _g) 
+	: Parent(_g) {}
+
+      EdgeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
+	return operator=<EdgeMap>(cmap);
       }
 
@@ -577,5 +577,5 @@
       EdgeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -594,5 +594,5 @@
       return edge;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -620,5 +620,5 @@
       arc_notifier.clear();
     }
-
+    
   };
 
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 1195)
+++ lemon/bits/graph_extender.h	(revision 1157)
@@ -57,9 +57,9 @@
     }
 
-    static Node fromId(int id, Node) {
+    Node fromId(int id, Node) const {
       return Parent::nodeFromId(id);
     }
 
-    static Arc fromId(int id, Arc) {
+    Arc fromId(int id, Arc) const {
       return Parent::arcFromId(id);
     }
@@ -356,13 +356,13 @@
     }
 
-    static Node fromId(int id, Node) {
+    Node fromId(int id, Node) const {
       return Parent::nodeFromId(id);
     }
 
-    static Arc fromId(int id, Arc) {
+    Arc fromId(int id, Arc) const {
       return Parent::arcFromId(id);
     }
 
-    static Edge fromId(int id, Edge) {
+    Edge fromId(int id, Edge) const {
       return Parent::edgeFromId(id);
     }
@@ -747,585 +747,4 @@
   };
 
-  // \ingroup _graphbits
-  //
-  // \brief Extender for the BpGraphs
-  template <typename Base>
-  class BpGraphExtender : public Base {
-    typedef Base Parent;
-
-  public:
-
-    typedef BpGraphExtender BpGraph;
-
-    typedef True UndirectedTag;
-
-    typedef typename Parent::Node Node;
-    typedef typename Parent::RedNode RedNode;
-    typedef typename Parent::BlueNode BlueNode;
-    typedef typename Parent::Arc Arc;
-    typedef typename Parent::Edge Edge;
-
-    // BpGraph extension
-
-    using Parent::first;
-    using Parent::next;
-    using Parent::id;
-
-    int maxId(Node) const {
-      return Parent::maxNodeId();
-    }
-
-    int maxId(RedNode) const {
-      return Parent::maxRedId();
-    }
-
-    int maxId(BlueNode) const {
-      return Parent::maxBlueId();
-    }
-
-    int maxId(Arc) const {
-      return Parent::maxArcId();
-    }
-
-    int maxId(Edge) const {
-      return Parent::maxEdgeId();
-    }
-
-    static Node fromId(int id, Node) {
-      return Parent::nodeFromId(id);
-    }
-
-    static Arc fromId(int id, Arc) {
-      return Parent::arcFromId(id);
-    }
-
-    static Edge fromId(int id, Edge) {
-      return Parent::edgeFromId(id);
-    }
-
-    Node u(Edge e) const { return this->redNode(e); }
-    Node v(Edge e) const { return this->blueNode(e); }
-
-    Node oppositeNode(const Node &n, const Edge &e) const {
-      if( n == u(e))
-        return v(e);
-      else if( n == v(e))
-        return u(e);
-      else
-        return INVALID;
-    }
-
-    Arc oppositeArc(const Arc &arc) const {
-      return Parent::direct(arc, !Parent::direction(arc));
-    }
-
-    using Parent::direct;
-    Arc direct(const Edge &edge, const Node &node) const {
-      return Parent::direct(edge, Parent::redNode(edge) == node);
-    }
-
-    RedNode asRedNode(const Node& node) const {
-      if (node == INVALID || Parent::blue(node)) {
-        return INVALID;
-      } else {
-        return Parent::asRedNodeUnsafe(node);
-      }
-    }
-
-    BlueNode asBlueNode(const Node& node) const {
-      if (node == INVALID || Parent::red(node)) {
-        return INVALID;
-      } else {
-        return Parent::asBlueNodeUnsafe(node);
-      }
-    }
-
-    // Alterable extension
-
-    typedef AlterationNotifier<BpGraphExtender, Node> NodeNotifier;
-    typedef AlterationNotifier<BpGraphExtender, RedNode> RedNodeNotifier; 
-    typedef AlterationNotifier<BpGraphExtender, BlueNode> BlueNodeNotifier;
-    typedef AlterationNotifier<BpGraphExtender, Arc> ArcNotifier;
-    typedef AlterationNotifier<BpGraphExtender, Edge> EdgeNotifier;
-
-
-  protected:
-
-    mutable NodeNotifier node_notifier;
-    mutable RedNodeNotifier red_node_notifier;
-    mutable BlueNodeNotifier blue_node_notifier;
-    mutable ArcNotifier arc_notifier;
-    mutable EdgeNotifier edge_notifier;
-
-  public:
-
-    NodeNotifier& notifier(Node) const {
-      return node_notifier;
-    }
-
-    RedNodeNotifier& notifier(RedNode) const {
-      return red_node_notifier;
-    }
-
-    BlueNodeNotifier& notifier(BlueNode) const {
-      return blue_node_notifier;
-    }
-
-    ArcNotifier& notifier(Arc) const {
-      return arc_notifier;
-    }
-
-    EdgeNotifier& notifier(Edge) const {
-      return edge_notifier;
-    }
-
-
-
-    class NodeIt : public Node {
-      const BpGraph* _graph;
-    public:
-
-      NodeIt() {}
-
-      NodeIt(Invalid i) : Node(i) { }
-
-      explicit NodeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const BpGraph& graph, const Node& node)
-        : Node(node), _graph(&graph) {}
-
-      NodeIt& operator++() {
-        _graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    class RedNodeIt : public RedNode {
-      const BpGraph* _graph;
-    public:
-
-      RedNodeIt() {}
-
-      RedNodeIt(Invalid i) : RedNode(i) { }
-
-      explicit RedNodeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<RedNode&>(*this));
-      }
-
-      RedNodeIt(const BpGraph& graph, const RedNode& node)
-        : RedNode(node), _graph(&graph) {}
-
-      RedNodeIt& operator++() {
-        _graph->next(static_cast<RedNode&>(*this));
-        return *this;
-      }
-
-    };
-
-    class BlueNodeIt : public BlueNode {
-      const BpGraph* _graph;
-    public:
-
-      BlueNodeIt() {}
-
-      BlueNodeIt(Invalid i) : BlueNode(i) { }
-
-      explicit BlueNodeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<BlueNode&>(*this));
-      }
-
-      BlueNodeIt(const BpGraph& graph, const BlueNode& node)
-        : BlueNode(node), _graph(&graph) {}
-
-      BlueNodeIt& operator++() {
-        _graph->next(static_cast<BlueNode&>(*this));
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
-      const BpGraph* _graph;
-    public:
-
-      ArcIt() { }
-
-      ArcIt(Invalid i) : Arc(i) { }
-
-      explicit ArcIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const BpGraph& graph, const Arc& arc) :
-        Arc(arc), _graph(&graph) { }
-
-      ArcIt& operator++() {
-        _graph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
-      const BpGraph* _graph;
-    public:
-
-      OutArcIt() { }
-
-      OutArcIt(Invalid i) : Arc(i) { }
-
-      OutArcIt(const BpGraph& graph, const Node& node)
-        : _graph(&graph) {
-        _graph->firstOut(*this, node);
-      }
-
-      OutArcIt(const BpGraph& graph, const Arc& arc)
-        : Arc(arc), _graph(&graph) {}
-
-      OutArcIt& operator++() {
-        _graph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
-      const BpGraph* _graph;
-    public:
-
-      InArcIt() { }
-
-      InArcIt(Invalid i) : Arc(i) { }
-
-      InArcIt(const BpGraph& graph, const Node& node)
-        : _graph(&graph) {
-        _graph->firstIn(*this, node);
-      }
-
-      InArcIt(const BpGraph& graph, const Arc& arc) :
-        Arc(arc), _graph(&graph) {}
-
-      InArcIt& operator++() {
-        _graph->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-
-    class EdgeIt : public Parent::Edge {
-      const BpGraph* _graph;
-    public:
-
-      EdgeIt() { }
-
-      EdgeIt(Invalid i) : Edge(i) { }
-
-      explicit EdgeIt(const BpGraph& graph) : _graph(&graph) {
-        _graph->first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const BpGraph& graph, const Edge& edge) :
-        Edge(edge), _graph(&graph) { }
-
-      EdgeIt& operator++() {
-        _graph->next(*this);
-        return *this;
-      }
-
-    };
-
-    class IncEdgeIt : public Parent::Edge {
-      friend class BpGraphExtender;
-      const BpGraph* _graph;
-      bool _direction;
-    public:
-
-      IncEdgeIt() { }
-
-      IncEdgeIt(Invalid i) : Edge(i), _direction(false) { }
-
-      IncEdgeIt(const BpGraph& graph, const Node &node) : _graph(&graph) {
-        _graph->firstInc(*this, _direction, node);
-      }
-
-      IncEdgeIt(const BpGraph& graph, const Edge &edge, const Node &node)
-        : _graph(&graph), Edge(edge) {
-        _direction = (_graph->source(edge) == node);
-      }
-
-      IncEdgeIt& operator++() {
-        _graph->nextInc(*this, _direction);
-        return *this;
-      }
-    };
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the source in this case) of the iterator
-    Node baseNode(const OutArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the target in this case) of the
-    // iterator
-    Node runningNode(const OutArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the target in this case) of the iterator
-    Node baseNode(const InArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the source in this case) of the
-    // iterator
-    Node runningNode(const InArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-
-    // Base node of the iterator
-    //
-    // Returns the base node of the iterator
-    Node baseNode(const IncEdgeIt &edge) const {
-      return edge._direction ? this->u(edge) : this->v(edge);
-    }
-    // Running node of the iterator
-    //
-    // Returns the running node of the iterator
-    Node runningNode(const IncEdgeIt &edge) const {
-      return edge._direction ? this->v(edge) : this->u(edge);
-    }
-
-    // Mappable extension
-
-    template <typename _Value>
-    class NodeMap
-      : public MapExtender<DefaultMap<BpGraph, Node, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, Node, _Value> > Parent;
-
-    public:
-      explicit NodeMap(const BpGraph& bpgraph)
-        : Parent(bpgraph) {}
-      NodeMap(const BpGraph& bpgraph, const _Value& value)
-        : Parent(bpgraph, value) {}
-
-    private:
-      NodeMap& operator=(const NodeMap& cmap) {
-        return operator=<NodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      NodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename _Value>
-    class RedNodeMap
-      : public MapExtender<DefaultMap<BpGraph, RedNode, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, RedNode, _Value> > Parent;
-
-    public:
-      explicit RedNodeMap(const BpGraph& bpgraph)
-        : Parent(bpgraph) {}
-      RedNodeMap(const BpGraph& bpgraph, const _Value& value)
-        : Parent(bpgraph, value) {}
-
-    private:
-      RedNodeMap& operator=(const RedNodeMap& cmap) {
-        return operator=<RedNodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      RedNodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename _Value>
-    class BlueNodeMap
-      : public MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, BlueNode, _Value> > Parent;
-
-    public:
-      explicit BlueNodeMap(const BpGraph& bpgraph)
-        : Parent(bpgraph) {}
-      BlueNodeMap(const BpGraph& bpgraph, const _Value& value)
-        : Parent(bpgraph, value) {}
-
-    private:
-      BlueNodeMap& operator=(const BlueNodeMap& cmap) {
-        return operator=<BlueNodeMap>(cmap);
-      }
-
-      template <typename CMap>
-      BlueNodeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    template <typename _Value>
-    class ArcMap
-      : public MapExtender<DefaultMap<BpGraph, Arc, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, Arc, _Value> > Parent;
-
-    public:
-      explicit ArcMap(const BpGraph& graph)
-        : Parent(graph) {}
-      ArcMap(const BpGraph& graph, const _Value& value)
-        : Parent(graph, value) {}
-
-    private:
-      ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
-      }
-
-      template <typename CMap>
-      ArcMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-    };
-
-
-    template <typename _Value>
-    class EdgeMap
-      : public MapExtender<DefaultMap<BpGraph, Edge, _Value> > {
-      typedef MapExtender<DefaultMap<BpGraph, Edge, _Value> > Parent;
-
-    public:
-      explicit EdgeMap(const BpGraph& graph)
-        : Parent(graph) {}
-
-      EdgeMap(const BpGraph& graph, const _Value& value)
-        : Parent(graph, value) {}
-
-    private:
-      EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
-      }
-
-      template <typename CMap>
-      EdgeMap& operator=(const CMap& cmap) {
-        Parent::operator=(cmap);
-        return *this;
-      }
-
-    };
-
-    // Alteration extension
-
-    RedNode addRedNode() {
-      RedNode node = Parent::addRedNode();
-      notifier(RedNode()).add(node);
-      notifier(Node()).add(node);
-      return node;
-    }
-
-    BlueNode addBlueNode() {
-      BlueNode node = Parent::addBlueNode();
-      notifier(BlueNode()).add(node);
-      notifier(Node()).add(node);
-      return node;
-    }
-
-    Edge addEdge(const RedNode& from, const BlueNode& to) {
-      Edge edge = Parent::addEdge(from, to);
-      notifier(Edge()).add(edge);
-      std::vector<Arc> av;
-      av.push_back(Parent::direct(edge, true));
-      av.push_back(Parent::direct(edge, false));
-      notifier(Arc()).add(av);
-      return edge;
-    }
-
-    void clear() {
-      notifier(Arc()).clear();
-      notifier(Edge()).clear();
-      notifier(Node()).clear();
-      notifier(BlueNode()).clear();
-      notifier(RedNode()).clear();
-      Parent::clear();
-    }
-
-    template <typename BpGraph, typename NodeRefMap, typename EdgeRefMap>
-    void build(const BpGraph& graph, NodeRefMap& nodeRef,
-               EdgeRefMap& edgeRef) {
-      Parent::build(graph, nodeRef, edgeRef);
-      notifier(RedNode()).build();
-      notifier(BlueNode()).build();
-      notifier(Node()).build();
-      notifier(Edge()).build();
-      notifier(Arc()).build();
-    }
-
-    void erase(const Node& node) {
-      Arc arc;
-      Parent::firstOut(arc, node);
-      while (arc != INVALID ) {
-        erase(arc);
-        Parent::firstOut(arc, node);
-      }
-
-      Parent::firstIn(arc, node);
-      while (arc != INVALID ) {
-        erase(arc);
-        Parent::firstIn(arc, node);
-      }
-
-      if (Parent::red(node)) {
-        notifier(RedNode()).erase(this->asRedNodeUnsafe(node));
-      } else {
-        notifier(BlueNode()).erase(this->asBlueNodeUnsafe(node));
-      }
-
-      notifier(Node()).erase(node);
-      Parent::erase(node);
-    }
-
-    void erase(const Edge& edge) {
-      std::vector<Arc> av;
-      av.push_back(Parent::direct(edge, true));
-      av.push_back(Parent::direct(edge, false));
-      notifier(Arc()).erase(av);
-      notifier(Edge()).erase(edge);
-      Parent::erase(edge);
-    }
-
-    BpGraphExtender() {
-      red_node_notifier.setContainer(*this);
-      blue_node_notifier.setContainer(*this);
-      node_notifier.setContainer(*this);
-      arc_notifier.setContainer(*this);
-      edge_notifier.setContainer(*this);
-    }
-
-    ~BpGraphExtender() {
-      edge_notifier.clear();
-      arc_notifier.clear();
-      node_notifier.clear();
-      blue_node_notifier.clear();
-      red_node_notifier.clear();
-    }
-
-  };
-
 }
 
Index: lemon/bits/lock.h
===================================================================
--- lemon/bits/lock.h	(revision 1131)
+++ 	(revision )
@@ -1,65 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2012
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BITS_LOCK_H
-#define LEMON_BITS_LOCK_H
-
-#include <lemon/config.h>
-#if defined(LEMON_USE_PTHREAD)
-#include <pthread.h>
-#elif defined(LEMON_USE_WIN32_THREADS)
-#include <lemon/bits/windows.h>
-#endif
-
-namespace lemon {
-  namespace bits {
-
-#if defined(LEMON_USE_PTHREAD)
-    class Lock {
-    public:
-      Lock() {
-	pthread_mutex_init(&_lock, 0);
-      }
-      ~Lock() {
-	pthread_mutex_destroy(&_lock);
-      }
-      void lock() {
-	pthread_mutex_lock(&_lock);
-      }
-      void unlock() {
-	pthread_mutex_unlock(&_lock);
-      }
-
-    private:
-      pthread_mutex_t _lock;
-    };
-#elif defined(LEMON_USE_WIN32_THREADS)
-    class Lock : public WinLock {};
-#else
-    class Lock {
-    public:
-      Lock() {}
-      ~Lock() {}
-      void lock() {}
-      void unlock() {}
-    };    
-#endif
-  }
-}
-
-#endif
Index: lemon/bits/solver_bits.h
===================================================================
--- lemon/bits/solver_bits.h	(revision 1142)
+++ lemon/bits/solver_bits.h	(revision 1140)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/traits.h
===================================================================
--- lemon/bits/traits.h	(revision 1194)
+++ lemon/bits/traits.h	(revision 663)
@@ -149,86 +149,4 @@
         : Parent(_digraph, _value) {}
     };
-
-  };
-
-  template <typename GR, typename Enable = void>
-  struct RedNodeNotifierIndicator {
-    typedef InvalidType Type;
-  };
-  template <typename GR>
-  struct RedNodeNotifierIndicator<
-    GR,
-    typename enable_if<typename GR::RedNodeNotifier::Notifier, void>::type
-  > {
-    typedef typename GR::RedNodeNotifier Type;
-  };
-
-  template <typename GR>
-  class ItemSetTraits<GR, typename GR::RedNode> {
-  public:
-
-    typedef GR BpGraph;
-    typedef GR Graph;
-    typedef GR Digraph;
-
-    typedef typename GR::RedNode Item;
-    typedef typename GR::RedNodeIt ItemIt;
-
-    typedef typename RedNodeNotifierIndicator<GR>::Type ItemNotifier;
-
-    template <typename V>
-    class Map : public GR::template RedNodeMap<V> {
-      typedef typename GR::template RedNodeMap<V> Parent;
-
-    public:
-      typedef typename GR::template RedNodeMap<V> Type;
-      typedef typename Parent::Value Value;
-
-      Map(const GR& _bpgraph) : Parent(_bpgraph) {}
-      Map(const GR& _bpgraph, const Value& _value)
-        : Parent(_bpgraph, _value) {}
-
-     };
-
-  };
-
-  template <typename GR, typename Enable = void>
-  struct BlueNodeNotifierIndicator {
-    typedef InvalidType Type;
-  };
-  template <typename GR>
-  struct BlueNodeNotifierIndicator<
-    GR,
-    typename enable_if<typename GR::BlueNodeNotifier::Notifier, void>::type
-  > {
-    typedef typename GR::BlueNodeNotifier Type;
-  };
-
-  template <typename GR>
-  class ItemSetTraits<GR, typename GR::BlueNode> {
-  public:
-
-    typedef GR BpGraph;
-    typedef GR Graph;
-    typedef GR Digraph;
-
-    typedef typename GR::BlueNode Item;
-    typedef typename GR::BlueNodeIt ItemIt;
-
-    typedef typename BlueNodeNotifierIndicator<GR>::Type ItemNotifier;
-
-    template <typename V>
-    class Map : public GR::template BlueNodeMap<V> {
-      typedef typename GR::template BlueNodeMap<V> Parent;
-
-    public:
-      typedef typename GR::template BlueNodeMap<V> Type;
-      typedef typename Parent::Value Value;
-
-      Map(const GR& _bpgraph) : Parent(_bpgraph) {}
-      Map(const GR& _bpgraph, const Value& _value)
-        : Parent(_bpgraph, _value) {}
-
-     };
 
   };
Index: lemon/bits/windows.cc
===================================================================
--- lemon/bits/windows.cc	(revision 1163)
+++ lemon/bits/windows.cc	(revision 1053)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -99,5 +99,5 @@
       GetSystemTime(&time);
       char buf1[11], buf2[9], buf3[5];
-          if (GetDateFormat(MY_LOCALE, 0, &time,
+	  if (GetDateFormat(MY_LOCALE, 0, &time,
                         ("ddd MMM dd"), buf1, 11) &&
           GetTimeFormat(MY_LOCALE, 0, &time,
@@ -131,36 +131,4 @@
 #endif
     }
-
-    WinLock::WinLock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = new CRITICAL_SECTION;
-      InitializeCriticalSection(lock);
-      _repr = lock;
-#else
-      _repr = 0; //Just to avoid 'unused variable' warning with clang
-#endif
-    }
-    
-    WinLock::~WinLock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      DeleteCriticalSection(lock);
-      delete lock;
-#endif
-    }
-
-    void WinLock::lock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      EnterCriticalSection(lock);
-#endif
-    }
-
-    void WinLock::unlock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      LeaveCriticalSection(lock);
-#endif
-    }
   }
 }
Index: lemon/bits/windows.h
===================================================================
--- lemon/bits/windows.h	(revision 1131)
+++ lemon/bits/windows.h	(revision 576)
@@ -29,14 +29,4 @@
     std::string getWinFormattedDate();
     int getWinRndSeed();
-
-    class WinLock {
-    public:
-      WinLock();
-      ~WinLock();
-      void lock();
-      void unlock();
-    private:
-      void *_repr;
-    };
   }
 }
Index: lemon/bucket_heap.h
===================================================================
--- lemon/bucket_heap.h	(revision 956)
+++ lemon/bucket_heap.h	(revision 730)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,7 +20,7 @@
 #define LEMON_BUCKET_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Bucket heap implementation.
+///\brief Bucket Heap implementation.
 
 #include <vector>
@@ -54,39 +54,33 @@
   }
 
-  /// \ingroup heaps
-  ///
-  /// \brief Bucket heap data structure.
-  ///
-  /// This class implements the \e bucket \e heap data structure.
-  /// It practically conforms to the \ref concepts::Heap "heap concept",
-  /// but it has some limitations.
-  ///
-  /// The bucket heap is a very simple structure. It can store only
-  /// \c int priorities and it maintains a list of items for each priority
-  /// in the range <tt>[0..C)</tt>. So it should only be used when the
-  /// priorities are small. It is not intended to use as a Dijkstra heap.
-  ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
-  /// The default is \e min-heap. If this parameter is set to \c false,
-  /// then the comparison is reversed, so the top(), prio() and pop()
-  /// functions deal with the item having maximum priority instead of the
-  /// minimum.
-  ///
-  /// \sa SimpleBucketHeap
+  /// \ingroup auxdat
+  ///
+  /// \brief A Bucket Heap implementation.
+  ///
+  /// This class implements the \e bucket \e heap data structure. A \e heap
+  /// is a data structure for storing items with specified values called \e
+  /// priorities in such a way that finding the item with minimum priority is
+  /// efficient. The bucket heap is very simple implementation, it can store
+  /// only integer priorities and it stores for each priority in the
+  /// \f$ [0..C) \f$ range a list of items. So it should be used only when
+  /// the priorities are small. It is not intended to use as dijkstra heap.
+  ///
+  /// \param IM A read and write Item int map, used internally
+  /// to handle the cross references.
+  /// \param MIN If the given parameter is false then instead of the
+  /// minimum value the maximum can be retrivied with the top() and
+  /// prio() member functions.
   template <typename IM, bool MIN = true>
   class BucketHeap {
 
   public:
-
-    /// Type of the item-int map.
+    /// \e
+    typedef typename IM::Key Item;
+    /// \e
+    typedef int Prio;
+    /// \e
+    typedef std::pair<Item, Prio> Pair;
+    /// \e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
 
   private:
@@ -96,8 +90,8 @@
   public:
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -111,30 +105,28 @@
 
   public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
     explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
     int size() const { return _data.size(); }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _data.empty(); }
 
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference
+    /// map.  If you want to reuse a heap what is not surely empty you
+    /// should first clear the heap and after that you should set the
+    /// cross reference map for each item to \c PRE_HEAP.
     void clear() {
       _data.clear(); _first.clear(); _minimum = 0;
@@ -143,5 +135,5 @@
   private:
 
-    void relocateLast(int idx) {
+    void relocate_last(int idx) {
       if (idx + 1 < int(_data.size())) {
         _data[idx] = _data.back();
@@ -183,11 +175,8 @@
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \c p.first to the heap with priority \c p.second.
     /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair& p) {
       push(p.first, p.second);
@@ -196,9 +185,7 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) {
       int idx = _data.size();
@@ -211,8 +198,8 @@
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       while (_first[_minimum] == -1) {
@@ -222,8 +209,8 @@
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
@@ -233,7 +220,7 @@
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -244,25 +231,25 @@
       _iim[_data[idx].item] = -2;
       unlace(idx);
-      relocateLast(idx);
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
+      relocate_last(idx);
+    }
+
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap, if \c i was
+    /// already stored in the heap.
+    /// \param i The item to erase.
     void erase(const Item &i) {
       int idx = _iim[i];
       _iim[_data[idx].item] = -2;
       unlace(idx);
-      relocateLast(idx);
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
+      relocate_last(idx);
+    }
+
+
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \pre \c i must be in the heap.
+    /// \param i The item.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
@@ -270,10 +257,9 @@
     }
 
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
     /// \param i The item.
     /// \param p The priority.
@@ -289,10 +275,11 @@
     }
 
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+    /// \brief Decreases the priority of \c i to \c p.
+    ///
+    /// This method decreases the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at least \c
+    /// p relative to \c Compare.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
@@ -305,10 +292,11 @@
     }
 
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
@@ -318,11 +306,11 @@
     }
 
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
@@ -332,9 +320,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -372,27 +360,21 @@
   }; // class BucketHeap
 
-  /// \ingroup heaps
-  ///
-  /// \brief Simplified bucket heap data structure.
+  /// \ingroup auxdat
+  ///
+  /// \brief A Simplified Bucket Heap implementation.
   ///
   /// This class implements a simplified \e bucket \e heap data
-  /// structure. It does not provide some functionality, but it is
-  /// faster and simpler than BucketHeap. The main difference is
-  /// that BucketHeap stores a doubly-linked list for each key while
-  /// this class stores only simply-linked lists. It supports erasing
-  /// only for the item having minimum priority and it does not support
-  /// key increasing and decreasing.
-  ///
-  /// Note that this implementation does not conform to the
-  /// \ref concepts::Heap "heap concept" due to the lack of some
-  /// functionality.
-  ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
-  /// The default is \e min-heap. If this parameter is set to \c false,
-  /// then the comparison is reversed, so the top(), prio() and pop()
-  /// functions deal with the item having maximum priority instead of the
-  /// minimum.
+  /// structure.  It does not provide some functionality but it faster
+  /// and simplier data structure than the BucketHeap. The main
+  /// difference is that the BucketHeap stores for every key a double
+  /// linked list while this class stores just simple lists. In the
+  /// other way it does not support erasing each elements just the
+  /// minimal and it does not supports key increasing, decreasing.
+  ///
+  /// \param IM A read and write Item int map, used internally
+  /// to handle the cross references.
+  /// \param MIN If the given parameter is false then instead of the
+  /// minimum value the maximum can be retrivied with the top() and
+  /// prio() member functions.
   ///
   /// \sa BucketHeap
@@ -401,13 +383,8 @@
 
   public:
-
-    /// Type of the item-int map.
+    typedef typename IM::Key Item;
+    typedef int Prio;
+    typedef std::pair<Item, Prio> Pair;
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
 
   private:
@@ -417,8 +394,8 @@
   public:
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -433,30 +410,29 @@
   public:
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
     explicit SimpleBucketHeap(ItemIntMap &map)
       : _iim(map), _free(-1), _num(0), _minimum(0) {}
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// \brief Returns the number of items stored in the heap.
+    ///
+    /// The number of items stored in the heap.
     int size() const { return _num; }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _num == 0; }
 
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference
+    /// map.  If you want to reuse a heap what is not surely empty you
+    /// should first clear the heap and after that you should set the
+    /// cross reference map for each item to \c PRE_HEAP.
     void clear() {
       _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
@@ -465,8 +441,6 @@
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \c p.first to the heap with priority \c p.second.
     /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair& p) {
       push(p.first, p.second);
@@ -475,9 +449,7 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) {
       int idx;
@@ -500,8 +472,8 @@
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       while (_first[_minimum] == -1) {
@@ -511,8 +483,8 @@
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
@@ -522,7 +494,7 @@
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -538,13 +510,14 @@
     }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    /// \warning This operator is not a constant time function because
-    /// it scans the whole data structure to find the proper value.
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \warning This operator is not a constant time function
+    /// because it scans the whole data structure to find the proper
+    /// value.
+    /// \pre \c i must be in the heap.
+    /// \param i The item.
     Prio operator[](const Item &i) const {
-      for (int k = 0; k < int(_first.size()); ++k) {
+      for (int k = 0; k < _first.size(); ++k) {
         int idx = _first[k];
         while (idx != -1) {
@@ -558,11 +531,11 @@
     }
 
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
Index: lemon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 1254)
+++ 	(revision )
@@ -1,1015 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_CAPACITY_SCALING_H
-#define LEMON_CAPACITY_SCALING_H
-
-/// \ingroup min_cost_flow_algs
-///
-/// \file
-/// \brief Capacity Scaling algorithm for finding a minimum cost flow.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/bin_heap.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of CapacityScaling algorithm.
-  ///
-  /// Default traits class of CapacityScaling algorithm.
-  /// \tparam GR Digraph type.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values. By default it is \c int.
-  /// \tparam C The number type used for costs and potentials.
-  /// By default it is the same as \c V.
-  template <typename GR, typename V = int, typename C = V>
-  struct CapacityScalingDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef V Value;
-    /// The type of the arc costs
-    typedef C Cost;
-
-    /// \brief The type of the heap used for internal Dijkstra computations.
-    ///
-    /// The type of the heap used for internal Dijkstra computations.
-    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept,
-    /// its priority type must be \c Cost and its cross reference type
-    /// must be \ref RangeMap "RangeMap<int>".
-    typedef BinHeap<Cost, RangeMap<int> > Heap;
-  };
-
-  /// \addtogroup min_cost_flow_algs
-  /// @{
-
-  /// \brief Implementation of the Capacity Scaling algorithm for
-  /// finding a \ref min_cost_flow "minimum cost flow".
-  ///
-  /// \ref CapacityScaling implements the capacity scaling version
-  /// of the successive shortest path algorithm for finding a
-  /// \ref min_cost_flow "minimum cost flow" \cite amo93networkflows,
-  /// \cite edmondskarp72theoretical. It is an efficient dual
-  /// solution method, which runs in polynomial time
-  /// \f$O(m\log U (n+m)\log n)\f$, where <i>U</i> denotes the maximum
-  /// of node supply and arc capacity values.
-  ///
-  /// This algorithm is typically slower than \ref CostScaling and
-  /// \ref NetworkSimplex, but in special cases, it can be more
-  /// efficient than them.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
-  ///
-  /// Most of the parameters of the problem (except for the digraph)
-  /// can be given using separate functions, and the algorithm can be
-  /// executed using the \ref run() function. If some parameters are not
-  /// specified, then default values will be used.
-  ///
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref CapacityScalingDefaultTraits
-  /// "CapacityScalingDefaultTraits<GR, V, C>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-  ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning Capacity bounds and supply values must be integer, but
-  /// arc costs can be arbitrary real numbers.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
-#ifdef DOXYGEN
-  template <typename GR, typename V, typename C, typename TR>
-#else
-  template < typename GR, typename V = int, typename C = V,
-             typename TR = CapacityScalingDefaultTraits<GR, V, C> >
-#endif
-  class CapacityScaling
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef typename TR::Value Value;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// The type of the heap used for internal Dijkstra computations
-    typedef typename TR::Heap Heap;
-
-    /// \brief The \ref lemon::CapacityScalingDefaultTraits "traits class"
-    /// of the algorithm
-    typedef TR Traits;
-
-  public:
-
-    /// \brief Problem type constants for the \c run() function.
-    ///
-    /// Enum type containing the problem type constants that can be
-    /// returned by the \ref run() function of the algorithm.
-    enum ProblemType {
-      /// The problem has no feasible solution (flow).
-      INFEASIBLE,
-      /// The problem has optimal solution (i.e. it is feasible and
-      /// bounded), and the algorithm has found optimal flow and node
-      /// potentials (primal and dual solutions).
-      OPTIMAL,
-      /// The digraph contains an arc of negative cost and infinite
-      /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however, note that it could actually be bounded
-      /// over the feasible flows, but this algroithm cannot handle
-      /// these cases.
-      UNBOUNDED
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<Value> ValueVector;
-    typedef std::vector<Cost> CostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-  private:
-
-    // Data related to the underlying digraph
-    const GR &_graph;
-    int _node_num;
-    int _arc_num;
-    int _res_arc_num;
-    int _root;
-
-    // Parameters of the problem
-    bool _have_lower;
-    Value _sum_supply;
-
-    // Data structures for storing the digraph
-    IntNodeMap _node_id;
-    IntArcMap _arc_idf;
-    IntArcMap _arc_idb;
-    IntVector _first_out;
-    BoolVector _forward;
-    IntVector _source;
-    IntVector _target;
-    IntVector _reverse;
-
-    // Node and arc data
-    ValueVector _lower;
-    ValueVector _upper;
-    CostVector _cost;
-    ValueVector _supply;
-
-    ValueVector _res_cap;
-    CostVector _pi;
-    ValueVector _excess;
-    IntVector _excess_nodes;
-    IntVector _deficit_nodes;
-
-    Value _delta;
-    int _factor;
-    IntVector _pred;
-
-  public:
-
-    /// \brief Constant for infinite upper bounds (capacities).
-    ///
-    /// Constant for infinite upper bounds (capacities).
-    /// It is \c std::numeric_limits<Value>::infinity() if available,
-    /// \c std::numeric_limits<Value>::max() otherwise.
-    const Value INF;
-
-  private:
-
-    // Special implementation of the Dijkstra algorithm for finding
-    // shortest paths in the residual network of the digraph with
-    // respect to the reduced arc costs and modifying the node
-    // potentials according to the found distance labels.
-    class ResidualDijkstra
-    {
-    private:
-
-      int _node_num;
-      bool _geq;
-      const IntVector &_first_out;
-      const IntVector &_target;
-      const CostVector &_cost;
-      const ValueVector &_res_cap;
-      const ValueVector &_excess;
-      CostVector &_pi;
-      IntVector &_pred;
-
-      IntVector _proc_nodes;
-      CostVector _dist;
-
-    public:
-
-      ResidualDijkstra(CapacityScaling& cs) :
-        _node_num(cs._node_num), _geq(cs._sum_supply < 0),
-        _first_out(cs._first_out), _target(cs._target), _cost(cs._cost),
-        _res_cap(cs._res_cap), _excess(cs._excess), _pi(cs._pi),
-        _pred(cs._pred), _dist(cs._node_num)
-      {}
-
-      int run(int s, Value delta = 1) {
-        RangeMap<int> heap_cross_ref(_node_num, Heap::PRE_HEAP);
-        Heap heap(heap_cross_ref);
-        heap.push(s, 0);
-        _pred[s] = -1;
-        _proc_nodes.clear();
-
-        // Process nodes
-        while (!heap.empty() && _excess[heap.top()] > -delta) {
-          int u = heap.top(), v;
-          Cost d = heap.prio() + _pi[u], dn;
-          _dist[u] = heap.prio();
-          _proc_nodes.push_back(u);
-          heap.pop();
-
-          // Traverse outgoing residual arcs
-          int last_out = _geq ? _first_out[u+1] : _first_out[u+1] - 1;
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            if (_res_cap[a] < delta) continue;
-            v = _target[a];
-            switch (heap.state(v)) {
-              case Heap::PRE_HEAP:
-                heap.push(v, d + _cost[a] - _pi[v]);
-                _pred[v] = a;
-                break;
-              case Heap::IN_HEAP:
-                dn = d + _cost[a] - _pi[v];
-                if (dn < heap[v]) {
-                  heap.decrease(v, dn);
-                  _pred[v] = a;
-                }
-                break;
-              case Heap::POST_HEAP:
-                break;
-            }
-          }
-        }
-        if (heap.empty()) return -1;
-
-        // Update potentials of processed nodes
-        int t = heap.top();
-        Cost dt = heap.prio();
-        for (int i = 0; i < int(_proc_nodes.size()); ++i) {
-          _pi[_proc_nodes[i]] += _dist[_proc_nodes[i]] - dt;
-        }
-
-        return t;
-      }
-
-    }; //class ResidualDijkstra
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetHeapTraits : public Traits {
-      typedef T Heap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c Heap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c Heap
-    /// type, which is used for internal Dijkstra computations.
-    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept,
-    /// its priority type must be \c Cost and its cross reference type
-    /// must be \ref RangeMap "RangeMap<int>".
-    template <typename T>
-    struct SetHeap
-      : public CapacityScaling<GR, V, C, SetHeapTraits<T> > {
-      typedef  CapacityScaling<GR, V, C, SetHeapTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    CapacityScaling() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    CapacityScaling(const GR& graph) :
-      _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),
-      INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() :
-          std::numeric_limits<Value>::max())
-    {
-      // Check the number types
-      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
-        "The flow type of CapacityScaling must be signed");
-      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
-        "The cost type of CapacityScaling must be signed");
-
-      // Reset data structures
-      reset();
-    }
-
-    /// \name Parameters
-    /// The parameters of the algorithm can be specified using these
-    /// functions.
-
-    /// @{
-
-    /// \brief Set the lower bounds on the arcs.
-    ///
-    /// This function sets the lower bounds on the arcs.
-    /// If it is not used before calling \ref run(), the lower bounds
-    /// will be set to zero on all arcs.
-    ///
-    /// \param map An arc map storing the lower bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template <typename LowerMap>
-    CapacityScaling& lowerMap(const LowerMap& map) {
-      _have_lower = true;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _lower[_arc_idf[a]] = map[a];
-        _lower[_arc_idb[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the upper bounds (capacities) on the arcs.
-    ///
-    /// This function sets the upper bounds (capacities) on the arcs.
-    /// If it is not used before calling \ref run(), the upper bounds
-    /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
-    ///
-    /// \param map An arc map storing the upper bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename UpperMap>
-    CapacityScaling& upperMap(const UpperMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _upper[_arc_idf[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the costs of the arcs.
-    ///
-    /// This function sets the costs of the arcs.
-    /// If it is not used before calling \ref run(), the costs
-    /// will be set to \c 1 on all arcs.
-    ///
-    /// \param map An arc map storing the costs.
-    /// Its \c Value type must be convertible to the \c Cost type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename CostMap>
-    CapacityScaling& costMap(const CostMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _cost[_arc_idf[a]] =  map[a];
-        _cost[_arc_idb[a]] = -map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the supply values of the nodes.
-    ///
-    /// This function sets the supply values of the nodes.
-    /// If neither this function nor \ref stSupply() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// \param map A node map storing the supply values.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename SupplyMap>
-    CapacityScaling& supplyMap(const SupplyMap& map) {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _supply[_node_id[n]] = map[n];
-      }
-      return *this;
-    }
-
-    /// \brief Set single source and target nodes and a supply value.
-    ///
-    /// This function sets a single source node and a single target node
-    /// and the required flow value.
-    /// If neither this function nor \ref supplyMap() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
-    /// assigned to \c t and all other nodes have zero supply value.
-    ///
-    /// \param s The source node.
-    /// \param t The target node.
-    /// \param k The required amount of flow from node \c s to node \c t
-    /// (i.e. the supply of \c s and the demand of \c t).
-    ///
-    /// \return <tt>(*this)</tt>
-    CapacityScaling& stSupply(const Node& s, const Node& t, Value k) {
-      for (int i = 0; i != _node_num; ++i) {
-        _supply[i] = 0;
-      }
-      _supply[_node_id[s]] =  k;
-      _supply[_node_id[t]] = -k;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Execution control
-    /// The algorithm can be executed using \ref run().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    /// For example,
-    /// \code
-    ///   CapacityScaling<ListDigraph> cs(graph);
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
-    ///
-    /// \param factor The capacity scaling factor. It must be larger than
-    /// one to use scaling. If it is less or equal to one, then scaling
-    /// will be disabled.
-    ///
-    /// \return \c INFEASIBLE if no feasible flow exists,
-    /// \n \c OPTIMAL if the problem has optimal solution
-    /// (i.e. it is feasible and bounded), and the algorithm has found
-    /// optimal flow and node potentials (primal and dual solutions),
-    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
-    /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however, note that it could actually be
-    /// bounded over the feasible flows, but this algroithm cannot handle
-    /// these cases.
-    ///
-    /// \see ProblemType
-    /// \see resetParams(), reset()
-    ProblemType run(int factor = 4) {
-      _factor = factor;
-      ProblemType pt = init();
-      if (pt != OPTIMAL) return pt;
-      return start();
-    }
-
-    /// \brief Reset all the parameters that have been given before.
-    ///
-    /// This function resets all the paramaters that have been given
-    /// before using functions \ref lowerMap(), \ref upperMap(),
-    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// For example,
-    /// \code
-    ///   CapacityScaling<ListDigraph> cs(graph);
-    ///
-    ///   // First run
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    ///
-    ///   // Run again with modified cost map (resetParams() is not called,
-    ///   // so only the cost map have to be set again)
-    ///   cost[e] += 100;
-    ///   cs.costMap(cost).run();
-    ///
-    ///   // Run again from scratch using resetParams()
-    ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cs.resetParams();
-    ///   cs.upperMap(capacity).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CapacityScaling& resetParams() {
-      for (int i = 0; i != _node_num; ++i) {
-        _supply[i] = 0;
-      }
-      for (int j = 0; j != _res_arc_num; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _cost[j] = _forward[j] ? 1 : -1;
-      }
-      _have_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CapacityScaling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-      ++_node_num;
-
-      _first_out.resize(_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _supply.resize(_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _pi.resize(_node_num);
-      _excess.resize(_node_num);
-      _pred.resize(_node_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The \ref run() function must be called before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found flow.
-    ///
-    /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
-    ///
-    /// \note The return type of the function can be specified as a
-    /// template parameter. For example,
-    /// \code
-    ///   cs.totalCost<double>();
-    /// \endcode
-    /// It is useful if the total cost cannot be stored in the \c Cost
-    /// type of the algorithm, which is the default return type of the
-    /// function.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename Number>
-    Number totalCost() const {
-      Number c = 0;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int i = _arc_idb[a];
-        c += static_cast<Number>(_res_cap[i]) *
-             (-static_cast<Number>(_cost[i]));
-      }
-      return c;
-    }
-
-#ifndef DOXYGEN
-    Cost totalCost() const {
-      return totalCost<Cost>();
-    }
-#endif
-
-    /// \brief Return the flow on the given arc.
-    ///
-    /// This function returns the flow on the given arc.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value flow(const Arc& a) const {
-      return _res_cap[_arc_idb[a]];
-    }
-
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
-    ///
-    /// This function copies the flow value on each arc into the given
-    /// map. The \c Value type of the algorithm must be convertible to
-    /// the \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename FlowMap>
-    void flowMap(FlowMap &map) const {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        map.set(a, _res_cap[_arc_idb[a]]);
-      }
-    }
-
-    /// \brief Return the potential (dual value) of the given node.
-    ///
-    /// This function returns the potential (dual value) of the
-    /// given node.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Cost potential(const Node& n) const {
-      return _pi[_node_id[n]];
-    }
-
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
-    ///
-    /// This function copies the potential (dual value) of each node
-    /// into the given map.
-    /// The \c Cost type of the algorithm must be convertible to the
-    /// \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename PotentialMap>
-    void potentialMap(PotentialMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map.set(n, _pi[_node_id[n]]);
-      }
-    }
-
-    /// @}
-
-  private:
-
-    // Initialize the algorithm
-    ProblemType init() {
-      if (_node_num <= 1) return INFEASIBLE;
-
-      // Check the sum of supply values
-      _sum_supply = 0;
-      for (int i = 0; i != _root; ++i) {
-        _sum_supply += _supply[i];
-      }
-      if (_sum_supply > 0) return INFEASIBLE;
-
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
-
-      // Initialize vectors
-      for (int i = 0; i != _root; ++i) {
-        _pi[i] = 0;
-        _excess[i] = _supply[i];
-      }
-
-      // Remove non-zero lower bounds
-      const Value MAX = std::numeric_limits<Value>::max();
-      int last_out;
-      if (_have_lower) {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j]) {
-              Value c = _lower[j];
-              if (c >= 0) {
-                _res_cap[j] = _upper[j] < MAX ? _upper[j] - c : INF;
-              } else {
-                _res_cap[j] = _upper[j] < MAX + c ? _upper[j] - c : INF;
-              }
-              _excess[i] -= c;
-              _excess[_target[j]] += c;
-            } else {
-              _res_cap[j] = 0;
-            }
-          }
-        }
-      } else {
-        for (int j = 0; j != _res_arc_num; ++j) {
-          _res_cap[j] = _forward[j] ? _upper[j] : 0;
-        }
-      }
-
-      // Handle negative costs
-      for (int i = 0; i != _root; ++i) {
-        last_out = _first_out[i+1] - 1;
-        for (int j = _first_out[i]; j != last_out; ++j) {
-          Value rc = _res_cap[j];
-          if (_cost[j] < 0 && rc > 0) {
-            if (rc >= MAX) return UNBOUNDED;
-            _excess[i] -= rc;
-            _excess[_target[j]] += rc;
-            _res_cap[j] = 0;
-            _res_cap[_reverse[j]] += rc;
-          }
-        }
-      }
-
-      // Handle GEQ supply type
-      if (_sum_supply < 0) {
-        _pi[_root] = 0;
-        _excess[_root] = -_sum_supply;
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = -_sum_supply + 1;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      } else {
-        _pi[_root] = 0;
-        _excess[_root] = 0;
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = 1;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      }
-
-      // Initialize delta value
-      if (_factor > 1) {
-        // With scaling
-        Value max_sup = 0, max_dem = 0, max_cap = 0;
-        for (int i = 0; i != _root; ++i) {
-          Value ex = _excess[i];
-          if ( ex > max_sup) max_sup =  ex;
-          if (-ex > max_dem) max_dem = -ex;
-          int last_out = _first_out[i+1] - 1;
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_res_cap[j] > max_cap) max_cap = _res_cap[j];
-          }
-        }
-        max_sup = std::min(std::min(max_sup, max_dem), max_cap);
-        for (_delta = 1; 2 * _delta <= max_sup; _delta *= 2) ;
-      } else {
-        // Without scaling
-        _delta = 1;
-      }
-
-      return OPTIMAL;
-    }
-    
-    // Check if the upper bound is greater or equal to the lower bound
-    // on each arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_upper[j] < _lower[j]) return false;
-      }
-      return true;
-    }
-
-    ProblemType start() {
-      // Execute the algorithm
-      ProblemType pt;
-      if (_delta > 1)
-        pt = startWithScaling();
-      else
-        pt = startWithoutScaling();
-
-      // Handle non-zero lower bounds
-      if (_have_lower) {
-        int limit = _first_out[_root];
-        for (int j = 0; j != limit; ++j) {
-          if (!_forward[j]) _res_cap[j] += _lower[j];
-        }
-      }
-
-      // Shift potentials if necessary
-      Cost pr = _pi[_root];
-      if (_sum_supply < 0 || pr > 0) {
-        for (int i = 0; i != _node_num; ++i) {
-          _pi[i] -= pr;
-        }
-      }
-
-      return pt;
-    }
-
-    // Execute the capacity scaling algorithm
-    ProblemType startWithScaling() {
-      // Perform capacity scaling phases
-      int s, t;
-      ResidualDijkstra _dijkstra(*this);
-      while (true) {
-        // Saturate all arcs not satisfying the optimality condition
-        int last_out;
-        for (int u = 0; u != _node_num; ++u) {
-          last_out = _sum_supply < 0 ?
-            _first_out[u+1] : _first_out[u+1] - 1;
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            int v = _target[a];
-            Cost c = _cost[a] + _pi[u] - _pi[v];
-            Value rc = _res_cap[a];
-            if (c < 0 && rc >= _delta) {
-              _excess[u] -= rc;
-              _excess[v] += rc;
-              _res_cap[a] = 0;
-              _res_cap[_reverse[a]] += rc;
-            }
-          }
-        }
-
-        // Find excess nodes and deficit nodes
-        _excess_nodes.clear();
-        _deficit_nodes.clear();
-        for (int u = 0; u != _node_num; ++u) {
-          Value ex = _excess[u];
-          if (ex >=  _delta) _excess_nodes.push_back(u);
-          if (ex <= -_delta) _deficit_nodes.push_back(u);
-        }
-        int next_node = 0, next_def_node = 0;
-
-        // Find augmenting shortest paths
-        while (next_node < int(_excess_nodes.size())) {
-          // Check deficit nodes
-          if (_delta > 1) {
-            bool delta_deficit = false;
-            for ( ; next_def_node < int(_deficit_nodes.size());
-                    ++next_def_node ) {
-              if (_excess[_deficit_nodes[next_def_node]] <= -_delta) {
-                delta_deficit = true;
-                break;
-              }
-            }
-            if (!delta_deficit) break;
-          }
-
-          // Run Dijkstra in the residual network
-          s = _excess_nodes[next_node];
-          if ((t = _dijkstra.run(s, _delta)) == -1) {
-            if (_delta > 1) {
-              ++next_node;
-              continue;
-            }
-            return INFEASIBLE;
-          }
-
-          // Augment along a shortest path from s to t
-          Value d = std::min(_excess[s], -_excess[t]);
-          int u = t;
-          int a;
-          if (d > _delta) {
-            while ((a = _pred[u]) != -1) {
-              if (_res_cap[a] < d) d = _res_cap[a];
-              u = _source[a];
-            }
-          }
-          u = t;
-          while ((a = _pred[u]) != -1) {
-            _res_cap[a] -= d;
-            _res_cap[_reverse[a]] += d;
-            u = _source[a];
-          }
-          _excess[s] -= d;
-          _excess[t] += d;
-
-          if (_excess[s] < _delta) ++next_node;
-        }
-
-        if (_delta == 1) break;
-        _delta = _delta <= _factor ? 1 : _delta / _factor;
-      }
-
-      return OPTIMAL;
-    }
-
-    // Execute the successive shortest path algorithm
-    ProblemType startWithoutScaling() {
-      // Find excess nodes
-      _excess_nodes.clear();
-      for (int i = 0; i != _node_num; ++i) {
-        if (_excess[i] > 0) _excess_nodes.push_back(i);
-      }
-      if (_excess_nodes.size() == 0) return OPTIMAL;
-      int next_node = 0;
-
-      // Find shortest paths
-      int s, t;
-      ResidualDijkstra _dijkstra(*this);
-      while ( _excess[_excess_nodes[next_node]] > 0 ||
-              ++next_node < int(_excess_nodes.size()) )
-      {
-        // Run Dijkstra in the residual network
-        s = _excess_nodes[next_node];
-        if ((t = _dijkstra.run(s)) == -1) return INFEASIBLE;
-
-        // Augment along a shortest path from s to t
-        Value d = std::min(_excess[s], -_excess[t]);
-        int u = t;
-        int a;
-        if (d > 1) {
-          while ((a = _pred[u]) != -1) {
-            if (_res_cap[a] < d) d = _res_cap[a];
-            u = _source[a];
-          }
-        }
-        u = t;
-        while ((a = _pred[u]) != -1) {
-          _res_cap[a] -= d;
-          _res_cap[_reverse[a]] += d;
-          u = _source[a];
-        }
-        _excess[s] -= d;
-        _excess[t] += d;
-      }
-
-      return OPTIMAL;
-    }
-
-  }; //class CapacityScaling
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_CAPACITY_SCALING_H
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 1161)
+++ lemon/cbc.cc	(revision 1140)
@@ -90,16 +90,4 @@
   }
 
-  int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-    std::vector<int> indexes;
-    std::vector<Value> values;
-
-    for(ExprIterator it = b; it != e; ++it) {
-      indexes.push_back(it->first);
-      values.push_back(it->second);
-    }
-
-    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
-    return _prob->numberRows() - 1;
-  }
 
   void CbcMip::_eraseCol(int i) {
Index: lemon/cbc.h
===================================================================
--- lemon/cbc.h	(revision 1232)
+++ lemon/cbc.h	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,4 +17,5 @@
  */
 
+// -*- C++ -*-
 #ifndef LEMON_CBC_H
 #define LEMON_CBC_H
@@ -62,5 +63,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
@@ -121,5 +121,5 @@
     int _message_level;
 
-
+    
 
   };
Index: lemon/christofides_tsp.h
===================================================================
--- lemon/christofides_tsp.h	(revision 1250)
+++ 	(revision )
@@ -1,254 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_CHRISTOFIDES_TSP_H
-#define LEMON_CHRISTOFIDES_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Christofides algorithm for symmetric TSP
-
-#include <lemon/full_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/kruskal.h>
-#include <lemon/matching.h>
-#include <lemon/euler.h>
-
-namespace lemon {
-  
-  /// \ingroup tsp
-  ///
-  /// \brief Christofides algorithm for symmetric TSP.
-  ///
-  /// ChristofidesTsp implements Christofides' heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This a well-known approximation method for the TSP problem with
-  /// metric cost function.
-  /// It has a guaranteed approximation factor of 3/2 (i.e. it finds a tour
-  /// whose total cost is at most 3/2 of the optimum), but it usually
-  /// provides better solutions in practice.
-  /// This implementation runs in O(n<sup>3</sup>log(n)) time.
-  ///
-  /// The algorithm starts with a \ref spantree "minimum cost spanning tree" and
-  /// finds a \ref MaxWeightedPerfectMatching "minimum cost perfect matching"
-  /// in the subgraph induced by the nodes that have odd degree in the
-  /// spanning tree.
-  /// Finally, it constructs the tour from the \ref EulerIt "Euler traversal"
-  /// of the union of the spanning tree and the matching.
-  /// During this last step, the algorithm simply skips the visited nodes
-  /// (i.e. creates shortcuts) assuming that the triangle inequality holds
-  /// for the cost function.
-  ///
-  /// \tparam CM Type of the cost map.
-  ///
-  /// \warning CM::Value must be a signed number type.
-  template <typename CM>
-  class ChristofidesTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      std::vector<Node> _path;
-      Cost _sum;
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      ChristofidesTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-        
-        // Compute min. cost spanning tree
-        std::vector<Edge> tree;
-        kruskal(_gr, _cost, std::back_inserter(tree));
-        
-        FullGraph::NodeMap<int> deg(_gr, 0);
-        for (int i = 0; i != int(tree.size()); ++i) {
-          Edge e = tree[i];
-          ++deg[_gr.u(e)];
-          ++deg[_gr.v(e)];
-        }
-
-        // Copy the induced subgraph of odd nodes
-        std::vector<Node> odd_nodes;
-        for (NodeIt u(_gr); u != INVALID; ++u) {
-          if (deg[u] % 2 == 1) odd_nodes.push_back(u);
-        }
-  
-        SmartGraph sgr;
-        SmartGraph::EdgeMap<Cost> scost(sgr);
-        for (int i = 0; i != int(odd_nodes.size()); ++i) {
-          sgr.addNode();
-        }
-        for (int i = 0; i != int(odd_nodes.size()); ++i) {
-          for (int j = 0; j != int(odd_nodes.size()); ++j) {
-            if (j == i) continue;
-            SmartGraph::Edge e =
-              sgr.addEdge(sgr.nodeFromId(i), sgr.nodeFromId(j));
-            scost[e] = -_cost[_gr.edge(odd_nodes[i], odd_nodes[j])];
-          }
-        }
-        
-        // Compute min. cost perfect matching
-        MaxWeightedPerfectMatching<SmartGraph, SmartGraph::EdgeMap<Cost> >
-          mwpm(sgr, scost);
-        mwpm.run();
-        
-        for (SmartGraph::EdgeIt e(sgr); e != INVALID; ++e) {
-          if (mwpm.matching(e)) {
-            tree.push_back( _gr.edge(odd_nodes[sgr.id(sgr.u(e))],
-                                     odd_nodes[sgr.id(sgr.v(e))]) );
-          }
-        }
-        
-        // Join the spanning tree and the matching        
-        sgr.clear();
-        for (int i = 0; i != _gr.nodeNum(); ++i) {
-          sgr.addNode();
-        }
-        for (int i = 0; i != int(tree.size()); ++i) {
-          int ui = _gr.id(_gr.u(tree[i])),
-              vi = _gr.id(_gr.v(tree[i]));
-          sgr.addEdge(sgr.nodeFromId(ui), sgr.nodeFromId(vi));
-        }
-
-        // Compute the tour from the Euler traversal
-        SmartGraph::NodeMap<bool> visited(sgr, false);
-        for (EulerIt<SmartGraph> e(sgr); e != INVALID; ++e) {
-          SmartGraph::Node n = sgr.target(e);
-          if (!visited[n]) {
-            _path.push_back(_gr(sgr.id(n)));
-            visited[n] = true;
-          }
-        }
-
-        _sum = _cost[_gr.edge(_path.back(), _path.front())];
-        for (int i = 0; i < int(_path.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_path[i], _path[i+1])];
-        }
-
-        return _sum;
-      }
-
-      /// @}
-      
-      /// \name Query Functions
-      /// @{
-      
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-      
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-      
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-      
-      /// @}
-      
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 1250)
+++ lemon/circulation.h	(revision 1157)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -60,6 +60,6 @@
     /// \brief The type of supply map.
     ///
-    /// The type of the map that stores the signed supply values of the
-    /// nodes.
+    /// The type of the map that stores the signed supply values of the 
+    /// nodes. 
     /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef SM SupplyMap;
@@ -73,9 +73,5 @@
     /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
     /// concept.
-#ifdef DOXYGEN
-    typedef GR::ArcMap<Value> FlowMap;
-#else
     typedef typename Digraph::template ArcMap<Value> FlowMap;
-#endif
 
     /// \brief Instantiates a FlowMap.
@@ -92,10 +88,7 @@
     /// The elevator type used by the algorithm.
     ///
-    /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
-    typedef lemon::Elevator<GR, GR::Node> Elevator;
-#else
+    /// \sa Elevator
+    /// \sa LinkedElevator
     typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
-#endif
 
     /// \brief Instantiates an Elevator.
@@ -142,5 +135,5 @@
      \geq sup(u) \quad \forall u\in V, \f]
      \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
-
+     
      The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
      zero or negative in order to have a feasible solution (since the sum
@@ -152,5 +145,5 @@
      constraints have to be satisfied with equality, i.e. all demands
      have to be satisfied and all supplies have to be used.
-
+     
      If you need the opposite inequalities in the supply/demand constraints
      (i.e. the total demand is less than the total supply and all the demands
@@ -174,9 +167,4 @@
      \tparam SM The type of the supply map. The default map type is
      \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>".
-     \tparam TR The traits class that defines various types used by the
-     algorithm. By default, it is \ref CirculationDefaultTraits
-     "CirculationDefaultTraits<GR, LM, UM, SM>".
-     In most cases, this parameter should not be set directly,
-     consider to use the named template parameters instead.
   */
 #ifdef DOXYGEN
@@ -196,6 +184,5 @@
   public:
 
-    /// \brief The \ref lemon::CirculationDefaultTraits "traits class"
-    /// of the algorithm.
+    ///The \ref CirculationDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
     ///The type of the digraph the algorithm runs on.
@@ -313,5 +300,5 @@
     /// able to automatically created by the algorithm (i.e. the
     /// digraph and the maximum level should be passed to it).
-    /// However, an external elevator object could also be passed to the
+    /// However an external elevator object could also be passed to the
     /// algorithm with the \ref elevator(Elevator&) "elevator()" function
     /// before calling \ref run() or \ref init().
@@ -339,5 +326,5 @@
     /// \param graph The digraph the algorithm runs on.
     /// \param lower The lower bounds for the flow values on the arcs.
-    /// \param upper The upper bounds (capacities) for the flow values
+    /// \param upper The upper bounds (capacities) for the flow values 
     /// on the arcs.
     /// \param supply The signed supply values of the nodes.
@@ -464,8 +451,7 @@
     }
 
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
     Circulation& tolerance(const Tolerance& tolerance) {
       _tol = tolerance;
@@ -475,6 +461,5 @@
     /// \brief Returns a const reference to the tolerance.
     ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
+    /// Returns a const reference to the tolerance.
     const Tolerance& tolerance() const {
       return _tol;
@@ -483,6 +468,6 @@
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call \ref run().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
+    /// If you need more control on the initial solution or the execution,
+    /// first you have to call one of the \ref init() functions, then
     /// the \ref start() function.
 
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 1142)
+++ lemon/clp.cc	(revision 1140)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -76,17 +76,4 @@
   int ClpLp::_addRow() {
     _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
-    return _prob->numberRows() - 1;
-  }
-
-  int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-    std::vector<int> indexes;
-    std::vector<Value> values;
-
-    for(ExprIterator it = b; it != e; ++it) {
-      indexes.push_back(it->first);
-      values.push_back(it->second);
-    }
-
-    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
     return _prob->numberRows() - 1;
   }
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 956)
+++ lemon/clp.h	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -76,5 +76,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
@@ -139,5 +138,5 @@
 
     virtual void _messageLevel(MessageLevel);
-
+    
   public:
 
Index: lemon/concept_check.h
===================================================================
--- lemon/concept_check.h	(revision 1157)
+++ lemon/concept_check.h	(revision 1257)
@@ -59,5 +59,5 @@
 #if !defined(NDEBUG)
     void (Concept::*x)() = & Concept::constraints;
-    ignore_unused_variable_warning(x);
+    ::lemon::ignore_unused_variable_warning(x);
 #endif
   }
@@ -69,5 +69,5 @@
     typedef typename Concept::template Constraints<Type> ConceptCheck;
     void (ConceptCheck::*x)() = & ConceptCheck::constraints;
-    ignore_unused_variable_warning(x);
+    ::lemon::ignore_unused_variable_warning(x);
 #endif
   }
Index: lemon/concepts/bpgraph.h
===================================================================
--- lemon/concepts/bpgraph.h	(revision 1217)
+++ 	(revision )
@@ -1,1026 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-///\ingroup graph_concepts
-///\file
-///\brief The concept of undirected graphs.
-
-#ifndef LEMON_CONCEPTS_BPGRAPH_H
-#define LEMON_CONCEPTS_BPGRAPH_H
-
-#include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concept_check.h>
-#include <lemon/core.h>
-
-namespace lemon {
-  namespace concepts {
-
-    /// \ingroup graph_concepts
-    ///
-    /// \brief Class describing the concept of undirected bipartite graphs.
-    ///
-    /// This class describes the common interface of all undirected
-    /// bipartite graphs.
-    ///
-    /// Like all concept classes, it only provides an interface
-    /// without any sensible implementation. So any general algorithm for
-    /// undirected bipartite graphs should compile with this class,
-    /// but it will not run properly, of course.
-    /// An actual graph implementation like \ref ListBpGraph or
-    /// \ref SmartBpGraph may have additional functionality.
-    ///
-    /// The bipartite graphs also fulfill the concept of \ref Graph
-    /// "undirected graphs". Bipartite graphs provide a bipartition of
-    /// the node set, namely a red and blue set of the nodes. The
-    /// nodes can be iterated with the RedNodeIt and BlueNodeIt in the
-    /// two node sets. With RedNodeMap and BlueNodeMap values can be
-    /// assigned to the nodes in the two sets.
-    ///
-    /// The edges of the graph cannot connect two nodes of the same
-    /// set. The edges inherent orientation is from the red nodes to
-    /// the blue nodes.
-    ///
-    /// \sa Graph
-    class BpGraph {
-    private:
-      /// BpGraphs are \e not copy constructible. Use bpGraphCopy instead.
-      BpGraph(const BpGraph&) {}
-      /// \brief Assignment of a graph to another one is \e not allowed.
-      /// Use bpGraphCopy instead.
-      void operator=(const BpGraph&) {}
-
-    public:
-      /// Default constructor.
-      BpGraph() {}
-
-      /// \brief Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// This tag helps the \c enable_if technics to make compile time
-      /// specializations for undirected graphs.
-      typedef True UndirectedTag;
-
-      /// The node type of the graph
-
-      /// This class identifies a node of the graph. It also serves
-      /// as a base class of the node iterators,
-      /// thus they convert to this type.
-      class Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        Node() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        Node(const Node&) { }
-
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        Node(Invalid) { }
-        /// Equality operator
-
-        /// Equality operator.
-        ///
-        /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
-        bool operator==(Node) const { return true; }
-
-        /// Inequality operator
-
-        /// Inequality operator.
-        bool operator!=(Node) const { return true; }
-
-        /// Artificial ordering operator.
-
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the items; this order has nothing to do with the iteration
-        /// ordering of the items.
-        bool operator<(Node) const { return false; }
-
-      };
-
-      /// Class to represent red nodes.
-
-      /// This class represents the red nodes of the graph. It does
-      /// not supposed to be used directly, because the nodes can be
-      /// represented as Node instances. This class can be used as
-      /// template parameter for special map classes.
-      class RedNode : public Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        RedNode() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        RedNode(const RedNode&) : Node() { }
-
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        RedNode(Invalid) { }
-
-      };
-
-      /// Class to represent blue nodes.
-
-      /// This class represents the blue nodes of the graph. It does
-      /// not supposed to be used directly, because the nodes can be
-      /// represented as Node instances. This class can be used as
-      /// template parameter for special map classes.
-      class BlueNode : public Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        BlueNode() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        BlueNode(const BlueNode&) : Node() { }
-
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        BlueNode(Invalid) { }
-
-      };
-
-      /// Iterator class for the red nodes.
-
-      /// This iterator goes through each red node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of red nodes in a graph \c g of type \c %BpGraph like this:
-      ///\code
-      /// int count=0;
-      /// for (BpGraph::RedNodeIt n(g); n!=INVALID; ++n) ++count;
-      ///\endcode
-      class RedNodeIt : public RedNode {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        RedNodeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        RedNodeIt(const RedNodeIt& n) : RedNode(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        RedNodeIt(Invalid) { }
-        /// Sets the iterator to the first red node.
-
-        /// Sets the iterator to the first red node of the given
-        /// digraph.
-        explicit RedNodeIt(const BpGraph&) { }
-        /// Sets the iterator to the given red node.
-
-        /// Sets the iterator to the given red node of the given
-        /// digraph.
-        RedNodeIt(const BpGraph&, const RedNode&) { }
-        /// Next node.
-
-        /// Assign the iterator to the next red node.
-        ///
-        RedNodeIt& operator++() { return *this; }
-      };
-
-      /// Iterator class for the blue nodes.
-
-      /// This iterator goes through each blue node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of blue nodes in a graph \c g of type \c %BpGraph like this:
-      ///\code
-      /// int count=0;
-      /// for (BpGraph::BlueNodeIt n(g); n!=INVALID; ++n) ++count;
-      ///\endcode
-      class BlueNodeIt : public BlueNode {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        BlueNodeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        BlueNodeIt(const BlueNodeIt& n) : BlueNode(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        BlueNodeIt(Invalid) { }
-        /// Sets the iterator to the first blue node.
-
-        /// Sets the iterator to the first blue node of the given
-        /// digraph.
-        explicit BlueNodeIt(const BpGraph&) { }
-        /// Sets the iterator to the given blue node.
-
-        /// Sets the iterator to the given blue node of the given
-        /// digraph.
-        BlueNodeIt(const BpGraph&, const BlueNode&) { }
-        /// Next node.
-
-        /// Assign the iterator to the next blue node.
-        ///
-        BlueNodeIt& operator++() { return *this; }
-      };
-
-      /// Iterator class for the nodes.
-
-      /// This iterator goes through each node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of nodes in a graph \c g of type \c %BpGraph like this:
-      ///\code
-      /// int count=0;
-      /// for (BpGraph::NodeIt n(g); n!=INVALID; ++n) ++count;
-      ///\endcode
-      class NodeIt : public Node {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        NodeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        NodeIt(Invalid) { }
-        /// Sets the iterator to the first node.
-
-        /// Sets the iterator to the first node of the given digraph.
-        ///
-        explicit NodeIt(const BpGraph&) { }
-        /// Sets the iterator to the given node.
-
-        /// Sets the iterator to the given node of the given digraph.
-        ///
-        NodeIt(const BpGraph&, const Node&) { }
-        /// Next node.
-
-        /// Assign the iterator to the next node.
-        ///
-        NodeIt& operator++() { return *this; }
-      };
-
-
-      /// The edge type of the graph
-
-      /// This class identifies an edge of the graph. It also serves
-      /// as a base class of the edge iterators,
-      /// thus they will convert to this type.
-      class Edge {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        Edge() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        Edge(const Edge&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        Edge(Invalid) { }
-        /// Equality operator
-
-        /// Equality operator.
-        ///
-        /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
-        bool operator==(Edge) const { return true; }
-        /// Inequality operator
-
-        /// Inequality operator.
-        bool operator!=(Edge) const { return true; }
-
-        /// Artificial ordering operator.
-
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the edges; this order has nothing to do with the iteration
-        /// ordering of the edges.
-        bool operator<(Edge) const { return false; }
-      };
-
-      /// Iterator class for the edges.
-
-      /// This iterator goes through each edge of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of edges in a graph \c g of type \c %BpGraph as follows:
-      ///\code
-      /// int count=0;
-      /// for(BpGraph::EdgeIt e(g); e!=INVALID; ++e) ++count;
-      ///\endcode
-      class EdgeIt : public Edge {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        EdgeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        EdgeIt(const EdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        EdgeIt(Invalid) { }
-        /// Sets the iterator to the first edge.
-
-        /// Sets the iterator to the first edge of the given graph.
-        ///
-        explicit EdgeIt(const BpGraph&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
-        EdgeIt(const BpGraph&, const Edge&) { }
-        /// Next edge
-
-        /// Assign the iterator to the next edge.
-        ///
-        EdgeIt& operator++() { return *this; }
-      };
-
-      /// Iterator class for the incident edges of a node.
-
-      /// This iterator goes trough the incident undirected edges
-      /// of a certain node of a graph.
-      /// Its usage is quite simple, for example, you can compute the
-      /// degree (i.e. the number of incident edges) of a node \c n
-      /// in a graph \c g of type \c %BpGraph as follows.
-      ///
-      ///\code
-      /// int count=0;
-      /// for(BpGraph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
-      ///\endcode
-      ///
-      /// \warning Loop edges will be iterated twice.
-      class IncEdgeIt : public Edge {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        IncEdgeIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        IncEdgeIt(Invalid) { }
-        /// Sets the iterator to the first incident edge.
-
-        /// Sets the iterator to the first incident edge of the given node.
-        ///
-        IncEdgeIt(const BpGraph&, const Node&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
-        IncEdgeIt(const BpGraph&, const Edge&) { }
-        /// Next incident edge
-
-        /// Assign the iterator to the next incident edge
-        /// of the corresponding node.
-        IncEdgeIt& operator++() { return *this; }
-      };
-
-      /// The arc type of the graph
-
-      /// This class identifies a directed arc of the graph. It also serves
-      /// as a base class of the arc iterators,
-      /// thus they will convert to this type.
-      class Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
-        Arc() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
-        Arc(Invalid) { }
-        /// Equality operator
-
-        /// Equality operator.
-        ///
-        /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
-        bool operator==(Arc) const { return true; }
-        /// Inequality operator
-
-        /// Inequality operator.
-        bool operator!=(Arc) const { return true; }
-
-        /// Artificial ordering operator.
-
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the arcs; this order has nothing to do with the iteration
-        /// ordering of the arcs.
-        bool operator<(Arc) const { return false; }
-
-        /// Converison to \c Edge
-
-        /// Converison to \c Edge.
-        ///
-        operator Edge() const { return Edge(); }
-      };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each directed arc of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of arcs in a graph \c g of type \c %BpGraph as follows:
-      ///\code
-      /// int count=0;
-      /// for(BpGraph::ArcIt a(g); a!=INVALID; ++a) ++count;
-      ///\endcode
-      class ArcIt : public Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        ArcIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        ArcIt(Invalid) { }
-        /// Sets the iterator to the first arc.
-
-        /// Sets the iterator to the first arc of the given graph.
-        ///
-        explicit ArcIt(const BpGraph &g) { ignore_unused_variable_warning(g); }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
-        ArcIt(const BpGraph&, const Arc&) { }
-        /// Next arc
-
-        /// Assign the iterator to the next arc.
-        ///
-        ArcIt& operator++() { return *this; }
-      };
-
-      /// Iterator class for the outgoing arcs of a node.
-
-      /// This iterator goes trough the \e outgoing directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of outgoing arcs of a node \c n
-      /// in a graph \c g of type \c %BpGraph as follows.
-      ///\code
-      /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
-      ///\endcode
-      class OutArcIt : public Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        OutArcIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
-        OutArcIt(const BpGraph& n, const Node& g) {
-          ignore_unused_variable_warning(n);
-          ignore_unused_variable_warning(g);
-        }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
-        OutArcIt(const BpGraph&, const Arc&) { }
-        /// Next outgoing arc
-
-        /// Assign the iterator to the next
-        /// outgoing arc of the corresponding node.
-        OutArcIt& operator++() { return *this; }
-      };
-
-      /// Iterator class for the incoming arcs of a node.
-
-      /// This iterator goes trough the \e incoming directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of incoming arcs of a node \c n
-      /// in a graph \c g of type \c %BpGraph as follows.
-      ///\code
-      /// int count=0;
-      /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
-      ///\endcode
-      class InArcIt : public Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
-        InArcIt() { }
-        /// Copy constructor.
-
-        /// Copy constructor.
-        ///
-        InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
-        InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
-        InArcIt(const BpGraph& g, const Node& n) {
-          ignore_unused_variable_warning(n);
-          ignore_unused_variable_warning(g);
-        }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
-        InArcIt(const BpGraph&, const Arc&) { }
-        /// Next incoming arc
-
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
-        InArcIt& operator++() { return *this; }
-      };
-
-      /// \brief Standard graph map type for the nodes.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class NodeMap : public ReferenceMap<Node, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit NodeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        NodeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        NodeMap(const NodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
-        ///Assignment operator
-        template <typename CMap>
-        NodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the red nodes.
-      ///
-      /// Standard graph map type for the red nodes.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class RedNodeMap : public ReferenceMap<Node, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit RedNodeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        RedNodeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        RedNodeMap(const RedNodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
-        ///Assignment operator
-        template <typename CMap>
-        RedNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the blue nodes.
-      ///
-      /// Standard graph map type for the blue nodes.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class BlueNodeMap : public ReferenceMap<Node, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit BlueNodeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        BlueNodeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        BlueNodeMap(const BlueNodeMap& nm) :
-          ReferenceMap<Node, T, T&, const T&>(nm) { }
-        ///Assignment operator
-        template <typename CMap>
-        BlueNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit ArcMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        ArcMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        ArcMap(const ArcMap& em) :
-          ReferenceMap<Arc, T, T&, const T&>(em) { }
-        ///Assignment operator
-        template <typename CMap>
-        ArcMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Arc, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Standard graph map type for the edges.
-      ///
-      /// Standard graph map type for the edges.
-      /// It conforms to the ReferenceMap concept.
-      template<class T>
-      class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
-      {
-      public:
-
-        /// Constructor
-        explicit EdgeMap(const BpGraph&) { }
-        /// Constructor with given initial value
-        EdgeMap(const BpGraph&, T) { }
-
-      private:
-        ///Copy constructor
-        EdgeMap(const EdgeMap& em) :
-          ReferenceMap<Edge, T, T&, const T&>(em) {}
-        ///Assignment operator
-        template <typename CMap>
-        EdgeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Edge, T>, CMap>();
-          return *this;
-        }
-      };
-
-      /// \brief Gives back %true for red nodes.
-      ///
-      /// Gives back %true for red nodes.
-      bool red(const Node&) const { return true; }
-
-      /// \brief Gives back %true for blue nodes.
-      ///
-      /// Gives back %true for blue nodes.
-      bool blue(const Node&) const { return true; }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts unsafely the node to red node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts safely the node to red node
-      /// object. If the node is not from the red partition, then it
-      /// returns INVALID.
-      RedNode asRedNode(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. If the node is not from the blue partition, then it
-      /// returns INVALID.
-      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
-
-      /// \brief Gives back the red end node of the edge.
-      /// 
-      /// Gives back the red end node of the edge.
-      RedNode redNode(const Edge&) const { return RedNode(); }
-
-      /// \brief Gives back the blue end node of the edge.
-      /// 
-      /// Gives back the blue end node of the edge.
-      BlueNode blueNode(const Edge&) const { return BlueNode(); }
-
-      /// \brief The first node of the edge.
-      ///
-      /// It is a synonim for the \c redNode().
-      Node u(Edge) const { return INVALID; }
-
-      /// \brief The second node of the edge.
-      ///
-      /// It is a synonim for the \c blueNode().
-      Node v(Edge) const { return INVALID; }
-
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
-      Node source(Arc) const { return INVALID; }
-
-      /// \brief The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
-      Node target(Arc) const { return INVALID; }
-
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
-      int id(Node) const { return -1; }
-
-      /// \brief The red ID of the node.
-      ///
-      /// Returns the red ID of the given node.
-      int id(RedNode) const { return -1; }
-
-      /// \brief The blue ID of the node.
-      ///
-      /// Returns the blue ID of the given node.
-      int id(BlueNode) const { return -1; }
-
-      /// \brief The ID of the edge.
-      ///
-      /// Returns the ID of the given edge.
-      int id(Edge) const { return -1; }
-
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
-      int id(Arc) const { return -1; }
-
-      /// \brief The node with the given ID.
-      ///
-      /// Returns the node with the given ID.
-      /// \pre The argument should be a valid node ID in the graph.
-      Node nodeFromId(int) const { return INVALID; }
-
-      /// \brief The edge with the given ID.
-      ///
-      /// Returns the edge with the given ID.
-      /// \pre The argument should be a valid edge ID in the graph.
-      Edge edgeFromId(int) const { return INVALID; }
-
-      /// \brief The arc with the given ID.
-      ///
-      /// Returns the arc with the given ID.
-      /// \pre The argument should be a valid arc ID in the graph.
-      Arc arcFromId(int) const { return INVALID; }
-
-      /// \brief An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
-      int maxNodeId() const { return -1; }
-
-      /// \brief An upper bound on the red IDs.
-      ///
-      /// Returns an upper bound on the red IDs.
-      int maxRedId() const { return -1; }
-
-      /// \brief An upper bound on the blue IDs.
-      ///
-      /// Returns an upper bound on the blue IDs.
-      int maxBlueId() const { return -1; }
-
-      /// \brief An upper bound on the edge IDs.
-      ///
-      /// Returns an upper bound on the edge IDs.
-      int maxEdgeId() const { return -1; }
-
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
-      int maxArcId() const { return -1; }
-
-      /// \brief The direction of the arc.
-      ///
-      /// Returns \c true if the given arc goes from a red node to a blue node.
-      bool direction(Arc) const { return true; }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc
-      /// represents the given edge and its direction comes
-      /// from the bool parameter. If it is \c true, then the source of the node
-      /// will be a red node.
-      Arc direct(Edge, bool) const {
-        return INVALID;
-      }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc represents the given
-      /// edge and its source node is the given node.
-      Arc direct(Edge, Node) const {
-        return INVALID;
-      }
-
-      /// \brief The oppositely directed arc.
-      ///
-      /// Returns the oppositely directed arc representing the same edge.
-      Arc oppositeArc(Arc) const { return INVALID; }
-
-      /// \brief The opposite node on the edge.
-      ///
-      /// Returns the opposite node on the given edge.
-      Node oppositeNode(Node, Edge) const { return INVALID; }
-
-      void first(Node&) const {}
-      void next(Node&) const {}
-
-      void firstRed(RedNode&) const {}
-      void nextRed(RedNode&) const {}
-
-      void firstBlue(BlueNode&) const {}
-      void nextBlue(BlueNode&) const {}
-
-      void first(Edge&) const {}
-      void next(Edge&) const {}
-
-      void first(Arc&) const {}
-      void next(Arc&) const {}
-
-      void firstOut(Arc&, Node) const {}
-      void nextOut(Arc&) const {}
-
-      void firstIn(Arc&, Node) const {}
-      void nextIn(Arc&) const {}
-
-      void firstInc(Edge &, bool &, const Node &) const {}
-      void nextInc(Edge &, bool &) const {}
-
-      // The second parameter is dummy.
-      Node fromId(int, Node) const { return INVALID; }
-      // The second parameter is dummy.
-      Edge fromId(int, Edge) const { return INVALID; }
-      // The second parameter is dummy.
-      Arc fromId(int, Arc) const { return INVALID; }
-
-      // Dummy parameter.
-      int maxId(Node) const { return -1; }
-      // Dummy parameter.
-      int maxId(RedNode) const { return -1; }
-      // Dummy parameter.
-      int maxId(BlueNode) const { return -1; }
-      // Dummy parameter.
-      int maxId(Edge) const { return -1; }
-      // Dummy parameter.
-      int maxId(Arc) const { return -1; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incident edge iterator.
-      Node baseNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incident edge iterator.
-      Node runningNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given outgoing arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node baseNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given outgoing arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node runningNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incoming arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node baseNode(InArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incoming arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node runningNode(InArcIt) const { return INVALID; }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<BaseBpGraphComponent, _BpGraph>();
-          checkConcept<IterableBpGraphComponent<>, _BpGraph>();
-          checkConcept<IDableBpGraphComponent<>, _BpGraph>();
-          checkConcept<MappableBpGraphComponent<>, _BpGraph>();
-        }
-      };
-
-    };
-
-  }
-
-}
-
-#endif
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 1217)
+++ lemon/concepts/digraph.h	(revision 1257)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -36,38 +36,44 @@
     /// \brief Class describing the concept of directed graphs.
     ///
-    /// This class describes the common interface of all directed
-    /// graphs (digraphs).
+    /// This class describes the \ref concept "concept" of the
+    /// immutable directed digraphs.
     ///
-    /// Like all concept classes, it only provides an interface
-    /// without any sensible implementation. So any general algorithm for
-    /// directed graphs should compile with this class, but it will not
-    /// run properly, of course.
-    /// An actual digraph implementation like \ref ListDigraph or
-    /// \ref SmartDigraph may have additional functionality.
+    /// Note that actual digraph implementation like @ref ListDigraph or
+    /// @ref SmartDigraph may have several additional functionality.
     ///
-    /// \sa Graph
+    /// \sa concept
     class Digraph {
     private:
-      /// Diraphs are \e not copy constructible. Use DigraphCopy instead.
-      Digraph(const Digraph &) {}
-      /// \brief Assignment of a digraph to another one is \e not allowed.
-      /// Use DigraphCopy instead.
+      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+
+      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+      ///
+      Digraph(const Digraph &) {};
+      ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
+      ///\e not allowed. Use DigraphCopy() instead.
+
+      ///Assignment of \ref Digraph "Digraph"s to another ones are
+      ///\e not allowed.  Use DigraphCopy() instead.
+
       void operator=(const Digraph &) {}
-
     public:
-      /// Default constructor.
+      ///\e
+
+      /// Defalult constructor.
+
+      /// Defalult constructor.
+      ///
       Digraph() { }
-
-      /// The node type of the digraph
+      /// Class for identifying a node of the digraph
 
       /// This class identifies a node of the digraph. It also serves
       /// as a base class of the node iterators,
-      /// thus they convert to this type.
+      /// thus they will convert to this type.
       class Node {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Node() { }
         /// Copy constructor.
@@ -77,37 +83,38 @@
         Node(const Node&) { }
 
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator to be invalid.
         /// \sa Invalid for more details.
         Node(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Node) const { return true; }
 
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Node n)
+        ///
         bool operator!=(Node) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the nodes; this order has nothing to do with the iteration
-        /// ordering of the nodes.
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Node) const { return false; }
-      };
-
-      /// Iterator class for the nodes.
-
-      /// This iterator goes through each node of the digraph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of nodes in a digraph \c g of type \c %Digraph like this:
+
+      };
+
+      /// This iterator goes through each node.
+
+      /// This iterator goes through each node.
+      /// Its usage is quite simple, for example you can count the number
+      /// of nodes in digraph \c g of type \c Digraph like this:
       ///\code
       /// int count=0;
@@ -118,6 +125,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         NodeIt() { }
         /// Copy constructor.
@@ -126,18 +133,20 @@
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// Initialize the iterator to be invalid.
         /// \sa Invalid for more details.
         NodeIt(Invalid) { }
         /// Sets the iterator to the first node.
 
-        /// Sets the iterator to the first node of the given digraph.
-        ///
-        explicit NodeIt(const Digraph&) { }
-        /// Sets the iterator to the given node.
-
-        /// Sets the iterator to the given node of the given digraph.
-        ///
+        /// Sets the iterator to the first node of \c g.
+        ///
+        NodeIt(const Digraph&) { }
+        /// Node -> NodeIt conversion.
+
+        /// Sets the iterator to the node of \c the digraph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         NodeIt(const Digraph&, const Node&) { }
         /// Next node.
@@ -149,5 +158,5 @@
 
 
-      /// The arc type of the digraph
+      /// Class for identifying an arc of the digraph
 
       /// This class identifies an arc of the digraph. It also serves
@@ -158,6 +167,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -166,48 +175,49 @@
         ///
         Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Arc(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Arc n)
+        ///
         bool operator!=(Arc) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the arcs; this order has nothing to do with the iteration
-        /// ordering of the arcs.
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Arc) const { return false; }
       };
 
-      /// Iterator class for the outgoing arcs of a node.
+      /// This iterator goes trough the outgoing arcs of a node.
 
       /// This iterator goes trough the \e outgoing arcs of a certain node
       /// of a digraph.
-      /// Its usage is quite simple, for example, you can count the number
+      /// Its usage is quite simple, for example you can count the number
       /// of outgoing arcs of a node \c n
-      /// in a digraph \c g of type \c %Digraph as follows.
+      /// in digraph \c g of type \c Digraph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class OutArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
@@ -216,20 +226,21 @@
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
+        /// This constructor sets the iterator to the first outgoing arc.
+
+        /// This constructor sets the iterator to the first outgoing arc of
+        /// the node.
         OutArcIt(const Digraph&, const Node&) { }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// Arc -> OutArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         OutArcIt(const Digraph&, const Arc&) { }
-        /// Next outgoing arc
+        ///Next outgoing arc
 
         /// Assign the iterator to the next
@@ -238,21 +249,22 @@
       };
 
-      /// Iterator class for the incoming arcs of a node.
+      /// This iterator goes trough the incoming arcs of a node.
 
       /// This iterator goes trough the \e incoming arcs of a certain node
       /// of a digraph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of incoming arcs of a node \c n
-      /// in a digraph \c g of type \c %Digraph as follows.
+      /// Its usage is quite simple, for example you can count the number
+      /// of outgoing arcs of a node \c n
+      /// in digraph \c g of type \c Digraph as follows.
       ///\code
       /// int count=0;
-      /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class InArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         InArcIt() { }
         /// Copy constructor.
@@ -261,34 +273,34 @@
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
+        /// This constructor sets the iterator to first incoming arc.
+
+        /// This constructor set the iterator to the first incoming arc of
+        /// the node.
         InArcIt(const Digraph&, const Node&) { }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// Arc -> InArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         InArcIt(const Digraph&, const Arc&) { }
         /// Next incoming arc
 
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
+        /// Assign the iterator to the next inarc of the corresponding node.
+        ///
         InArcIt& operator++() { return *this; }
       };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each arc of the digraph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of arcs in a digraph \c g of type \c %Digraph as follows:
+      /// This iterator goes through each arc.
+
+      /// This iterator goes through each arc of a digraph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of arcs in a digraph \c g of type \c Digraph as follows:
       ///\code
       /// int count=0;
-      /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;
+      /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
       ///\endcode
       class ArcIt : public Arc {
@@ -296,6 +308,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         ArcIt() { }
         /// Copy constructor.
@@ -304,66 +316,56 @@
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         ArcIt(Invalid) { }
-        /// Sets the iterator to the first arc.
-
-        /// Sets the iterator to the first arc of the given digraph.
-        ///
-        explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// This constructor sets the iterator to the first arc.
+
+        /// This constructor sets the iterator to the first arc of \c g.
+        ///@param g the digraph
+        ArcIt(const Digraph& g) { ::lemon::ignore_unused_variable_warning(g); }
+        /// Arc -> ArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         ArcIt(const Digraph&, const Arc&) { }
-        /// Next arc
+        ///Next arc
 
         /// Assign the iterator to the next arc.
-        ///
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
+      ///Gives back the target node of an arc.
+
+      ///Gives back the target node of an arc.
+      ///
+      Node target(Arc) const { return INVALID; }
+      ///Gives back the source node of an arc.
+
+      ///Gives back the source node of an arc.
+      ///
       Node source(Arc) const { return INVALID; }
 
-      /// \brief The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
-      Node target(Arc) const { return INVALID; }
-
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
+      /// \brief Returns the ID of the node.
       int id(Node) const { return -1; }
 
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
+      /// \brief Returns the ID of the arc.
       int id(Arc) const { return -1; }
 
-      /// \brief The node with the given ID.
-      ///
-      /// Returns the node with the given ID.
-      /// \pre The argument should be a valid node ID in the digraph.
+      /// \brief Returns the node with the given ID.
+      ///
+      /// \pre The argument should be a valid node ID in the graph.
       Node nodeFromId(int) const { return INVALID; }
 
-      /// \brief The arc with the given ID.
-      ///
-      /// Returns the arc with the given ID.
-      /// \pre The argument should be a valid arc ID in the digraph.
+      /// \brief Returns the arc with the given ID.
+      ///
+      /// \pre The argument should be a valid arc ID in the graph.
       Arc arcFromId(int) const { return INVALID; }
 
-      /// \brief An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
+      /// \brief Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
 
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
+      /// \brief Returns an upper bound on the arc IDs.
       int maxArcId() const { return -1; }
 
@@ -391,49 +393,48 @@
       int maxId(Arc) const { return -1; }
 
-      /// \brief The opposite node on the arc.
-      ///
-      /// Returns the opposite node on the given arc.
-      Node oppositeNode(Node, Arc) const { return INVALID; }
-
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given outgoing arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node baseNode(OutArcIt) const { return INVALID; }
+      /// Gives back the base node of the iterator.
+      /// It is always the target of the pointed arc.
+      Node baseNode(const InArcIt&) const { return INVALID; }
 
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given outgoing arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node runningNode(OutArcIt) const { return INVALID; }
+      /// Gives back the running node of the iterator.
+      /// It is always the source of the pointed arc.
+      Node runningNode(const InArcIt&) const { return INVALID; }
 
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given incoming arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node baseNode(InArcIt) const { return INVALID; }
+      /// Gives back the base node of the iterator.
+      /// It is always the source of the pointed arc.
+      Node baseNode(const OutArcIt&) const { return INVALID; }
 
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given incoming arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node runningNode(InArcIt) const { return INVALID; }
-
-      /// \brief Standard graph map type for the nodes.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
+      /// Gives back the running node of the iterator.
+      /// It is always the target of the pointed arc.
+      Node runningNode(const OutArcIt&) const { return INVALID; }
+
+      /// \brief The opposite node on the given arc.
+      ///
+      /// Gives back the opposite node on the given arc.
+      Node oppositeNode(const Node&, const Arc&) const { return INVALID; }
+
+      /// \brief Reference map of the nodes to type \c T.
+      ///
+      /// Reference map of the nodes to type \c T.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
       public:
 
-        /// Constructor
-        explicit NodeMap(const Digraph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Digraph&) { }
+        ///\e
         NodeMap(const Digraph&, T) { }
 
       private:
         ///Copy constructor
-        NodeMap(const NodeMap& nm) :
+        NodeMap(const NodeMap& nm) : 
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator
@@ -445,17 +446,15 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
       public:
 
-        /// Constructor
-        explicit ArcMap(const Digraph&) { }
-        /// Constructor with given initial value
+        ///\e
+        ArcMap(const Digraph&) { }
+        ///\e
         ArcMap(const Digraph&, T) { }
-
       private:
         ///Copy constructor
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 1217)
+++ lemon/concepts/graph.h	(revision 1257)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,5 +19,5 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concept of undirected graphs.
+///\brief The concept of Undirected Graphs.
 
 #ifndef LEMON_CONCEPTS_GRAPH_H
@@ -25,6 +25,4 @@
 
 #include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concept_check.h>
 #include <lemon/core.h>
 
@@ -34,72 +32,61 @@
     /// \ingroup graph_concepts
     ///
-    /// \brief Class describing the concept of undirected graphs.
+    /// \brief Class describing the concept of Undirected Graphs.
     ///
-    /// This class describes the common interface of all undirected
-    /// graphs.
+    /// This class describes the common interface of all Undirected
+    /// Graphs.
     ///
-    /// Like all concept classes, it only provides an interface
-    /// without any sensible implementation. So any general algorithm for
-    /// undirected graphs should compile with this class, but it will not
+    /// As all concept describing classes it provides only interface
+    /// without any sensible implementation. So any algorithm for
+    /// undirected graph should compile with this class, but it will not
     /// run properly, of course.
-    /// An actual graph implementation like \ref ListGraph or
-    /// \ref SmartGraph may have additional functionality.
     ///
-    /// The undirected graphs also fulfill the concept of \ref Digraph
-    /// "directed graphs", since each edge can also be regarded as two
-    /// oppositely directed arcs.
-    /// Undirected graphs provide an Edge type for the undirected edges and
-    /// an Arc type for the directed arcs. The Arc type is convertible to
-    /// Edge or inherited from it, i.e. the corresponding edge can be
-    /// obtained from an arc.
-    /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt
-    /// and ArcMap classes can be used for the arcs (just like in digraphs).
-    /// Both InArcIt and OutArcIt iterates on the same edges but with
-    /// opposite direction. IncEdgeIt also iterates on the same edges
-    /// as OutArcIt and InArcIt, but it is not convertible to Arc,
-    /// only to Edge.
+    /// The LEMON undirected graphs also fulfill the concept of
+    /// directed graphs (\ref lemon::concepts::Digraph "Digraph
+    /// Concept"). Each edges can be seen as two opposite
+    /// directed arc and consequently the undirected graph can be
+    /// seen as the direceted graph of these directed arcs. The
+    /// Graph has the Edge inner class for the edges and
+    /// the Arc type for the directed arcs. The Arc type is
+    /// convertible to Edge or inherited from it so from a directed
+    /// arc we can get the represented edge.
     ///
-    /// In LEMON, each undirected edge has an inherent orientation.
-    /// Thus it can defined if an arc is forward or backward oriented in
-    /// an undirected graph with respect to this default oriantation of
-    /// the represented edge.
-    /// With the direction() and direct() functions the direction
-    /// of an arc can be obtained and set, respectively.
+    /// In the sense of the LEMON each edge has a default
+    /// direction (it should be in every computer implementation,
+    /// because the order of edge's nodes defines an
+    /// orientation). With the default orientation we can define that
+    /// the directed arc is forward or backward directed. With the \c
+    /// direction() and \c direct() function we can get the direction
+    /// of the directed arc and we can direct an edge.
     ///
-    /// Only nodes and edges can be added to or removed from an undirected
-    /// graph and the corresponding arcs are added or removed automatically.
-    ///
-    /// \sa Digraph
+    /// The EdgeIt is an iterator for the edges. We can use
+    /// the EdgeMap to map values for the edges. The InArcIt and
+    /// OutArcIt iterates on the same edges but with opposite
+    /// direction. The IncEdgeIt iterates also on the same edges
+    /// as the OutArcIt and InArcIt but it is not convertible to Arc just
+    /// to Edge.
     class Graph {
-    private:
-      /// Graphs are \e not copy constructible. Use GraphCopy instead.
-      Graph(const Graph&) {}
-      /// \brief Assignment of a graph to another one is \e not allowed.
-      /// Use GraphCopy instead.
-      void operator=(const Graph&) {}
-
     public:
-      /// Default constructor.
-      Graph() {}
-
-      /// \brief Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// This tag helps the \c enable_if technics to make compile time
+      /// \brief The undirected graph should be tagged by the
+      /// UndirectedTag.
+      ///
+      /// The undirected graph should be tagged by the UndirectedTag. This
+      /// tag helps the enable_if technics to make compile time
       /// specializations for undirected graphs.
       typedef True UndirectedTag;
 
-      /// The node type of the graph
-
-      /// This class identifies a node of the graph. It also serves
-      /// as a base class of the node iterators,
-      /// thus they convert to this type.
+      /// \brief The base type of node iterators,
+      /// or in other words, the trivial node iterator.
+      ///
+      /// This is the base type of each node iterator,
+      /// thus each kind of node iterator converts to this.
+      /// More precisely each kind of node iterator should be inherited
+      /// from the trivial node iterator.
       class Node {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Node() { }
         /// Copy constructor.
@@ -109,27 +96,27 @@
         Node(const Node&) { }
 
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator to be invalid.
         /// \sa Invalid for more details.
         Node(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Node) const { return true; }
 
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Node n)
+        ///
         bool operator!=(Node) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
         /// the items; this order has nothing to do with the iteration
         /// ordering of the items.
@@ -138,9 +125,9 @@
       };
 
-      /// Iterator class for the nodes.
-
-      /// This iterator goes through each node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of nodes in a graph \c g of type \c %Graph like this:
+      /// This iterator goes through each node.
+
+      /// This iterator goes through each node.
+      /// Its usage is quite simple, for example you can count the number
+      /// of nodes in graph \c g of type \c Graph like this:
       ///\code
       /// int count=0;
@@ -151,6 +138,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         NodeIt() { }
         /// Copy constructor.
@@ -159,18 +146,20 @@
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// Initialize the iterator to be invalid.
         /// \sa Invalid for more details.
         NodeIt(Invalid) { }
         /// Sets the iterator to the first node.
 
-        /// Sets the iterator to the first node of the given digraph.
-        ///
-        explicit NodeIt(const Graph&) { }
-        /// Sets the iterator to the given node.
-
-        /// Sets the iterator to the given node of the given digraph.
-        ///
+        /// Sets the iterator to the first node of \c g.
+        ///
+        NodeIt(const Graph&) { }
+        /// Node -> NodeIt conversion.
+
+        /// Sets the iterator to the node of \c the graph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         NodeIt(const Graph&, const Node&) { }
         /// Next node.
@@ -182,15 +171,14 @@
 
 
-      /// The edge type of the graph
-
-      /// This class identifies an edge of the graph. It also serves
-      /// as a base class of the edge iterators,
-      /// thus they will convert to this type.
+      /// The base type of the edge iterators.
+
+      /// The base type of the edge iterators.
+      ///
       class Edge {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Edge() { }
         /// Copy constructor.
@@ -199,36 +187,36 @@
         ///
         Edge(const Edge&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Edge(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Edge) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Edge n)
+        ///
         bool operator!=(Edge) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the edges; this order has nothing to do with the iteration
-        /// ordering of the edges.
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Edge) const { return false; }
       };
 
-      /// Iterator class for the edges.
-
-      /// This iterator goes through each edge of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of edges in a graph \c g of type \c %Graph as follows:
+      /// This iterator goes through each edge.
+
+      /// This iterator goes through each edge of a graph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of edges in a graph \c g of type \c Graph as follows:
       ///\code
       /// int count=0;
@@ -239,6 +227,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         EdgeIt() { }
         /// Copy constructor.
@@ -247,33 +235,36 @@
         ///
         EdgeIt(const EdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         EdgeIt(Invalid) { }
-        /// Sets the iterator to the first edge.
-
-        /// Sets the iterator to the first edge of the given graph.
-        ///
-        explicit EdgeIt(const Graph&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
+        /// This constructor sets the iterator to the first edge.
+
+        /// This constructor sets the iterator to the first edge.
+        EdgeIt(const Graph&) { }
+        /// Edge -> EdgeIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the edge-set, the iteration order is the
+        /// same.
         EdgeIt(const Graph&, const Edge&) { }
         /// Next edge
 
         /// Assign the iterator to the next edge.
-        ///
         EdgeIt& operator++() { return *this; }
       };
 
-      /// Iterator class for the incident edges of a node.
-
-      /// This iterator goes trough the incident undirected edges
-      /// of a certain node of a graph.
-      /// Its usage is quite simple, for example, you can compute the
-      /// degree (i.e. the number of incident edges) of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// \brief This iterator goes trough the incident undirected
+      /// arcs of a node.
+      ///
+      /// This iterator goes trough the incident edges
+      /// of a certain node of a graph. You should assume that the
+      /// loop arcs will be iterated twice.
+      ///
+      /// Its usage is quite simple, for example you can compute the
+      /// degree (i.e. count the number of incident arcs of a node \c n
+      /// in graph \c g of type \c Graph as follows.
       ///
       ///\code
@@ -281,12 +272,10 @@
       /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
-      ///
-      /// \warning Loop edges will be iterated twice.
       class IncEdgeIt : public Edge {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         IncEdgeIt() { }
         /// Copy constructor.
@@ -295,37 +284,38 @@
         ///
         IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         IncEdgeIt(Invalid) { }
-        /// Sets the iterator to the first incident edge.
-
-        /// Sets the iterator to the first incident edge of the given node.
-        ///
+        /// This constructor sets the iterator to first incident arc.
+
+        /// This constructor set the iterator to the first incident arc of
+        /// the node.
         IncEdgeIt(const Graph&, const Node&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
+        /// Edge -> IncEdgeIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         IncEdgeIt(const Graph&, const Edge&) { }
-        /// Next incident edge
-
-        /// Assign the iterator to the next incident edge
+        /// Next incident arc
+
+        /// Assign the iterator to the next incident arc
         /// of the corresponding node.
         IncEdgeIt& operator++() { return *this; }
       };
 
-      /// The arc type of the graph
-
-      /// This class identifies a directed arc of the graph. It also serves
-      /// as a base class of the arc iterators,
-      /// thus they will convert to this type.
+      /// The directed arc type.
+
+      /// The directed arc type. It can be converted to the
+      /// edge or it should be inherited from the undirected
+      /// edge.
       class Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -334,45 +324,41 @@
         ///
         Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Arc(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Arc n)
+        ///
         bool operator!=(Arc) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the arcs; this order has nothing to do with the iteration
-        /// ordering of the arcs.
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Arc) const { return false; }
 
-        /// Converison to \c Edge
-
-        /// Converison to \c Edge.
-        ///
+        /// Converison to Edge
         operator Edge() const { return Edge(); }
       };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each directed arc of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of arcs in a graph \c g of type \c %Graph as follows:
+      /// This iterator goes through each directed arc.
+
+      /// This iterator goes through each arc of a graph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of arcs in a graph \c g of type \c Graph as follows:
       ///\code
       /// int count=0;
-      /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;
+      /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
       ///\endcode
       class ArcIt : public Arc {
@@ -380,6 +366,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         ArcIt() { }
         /// Copy constructor.
@@ -388,43 +374,44 @@
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         ArcIt(Invalid) { }
-        /// Sets the iterator to the first arc.
-
-        /// Sets the iterator to the first arc of the given graph.
-        ///
-        explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// This constructor sets the iterator to the first arc.
+
+        /// This constructor sets the iterator to the first arc of \c g.
+        ///@param g the graph
+        ArcIt(const Graph &g) { ::lemon::ignore_unused_variable_warning(g); }
+        /// Arc -> ArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         ArcIt(const Graph&, const Arc&) { }
-        /// Next arc
+        ///Next arc
 
         /// Assign the iterator to the next arc.
-        ///
         ArcIt& operator++() { return *this; }
       };
 
-      /// Iterator class for the outgoing arcs of a node.
-
-      /// This iterator goes trough the \e outgoing directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
+      /// This iterator goes trough the outgoing directed arcs of a node.
+
+      /// This iterator goes trough the \e outgoing arcs of a certain node
+      /// of a graph.
+      /// Its usage is quite simple, for example you can count the number
       /// of outgoing arcs of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// in graph \c g of type \c Graph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class OutArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
@@ -433,23 +420,26 @@
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
+        /// This constructor sets the iterator to the first outgoing arc.
+
+        /// This constructor sets the iterator to the first outgoing arc of
+        /// the node.
+        ///@param n the node
+        ///@param g the graph
         OutArcIt(const Graph& n, const Node& g) {
-          ignore_unused_variable_warning(n);
-          ignore_unused_variable_warning(g);
+          ::lemon::ignore_unused_variable_warning(n);
+          ::lemon::ignore_unused_variable_warning(g);
         }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// Arc -> OutArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         OutArcIt(const Graph&, const Arc&) { }
-        /// Next outgoing arc
+        ///Next outgoing arc
 
         /// Assign the iterator to the next
@@ -458,21 +448,22 @@
       };
 
-      /// Iterator class for the incoming arcs of a node.
-
-      /// This iterator goes trough the \e incoming directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of incoming arcs of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// This iterator goes trough the incoming directed arcs of a node.
+
+      /// This iterator goes trough the \e incoming arcs of a certain node
+      /// of a graph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of outgoing arcs of a node \c n
+      /// in graph \c g of type \c Graph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class InArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         InArcIt() { }
         /// Copy constructor.
@@ -481,33 +472,35 @@
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
+        /// This constructor sets the iterator to first incoming arc.
+
+        /// This constructor set the iterator to the first incoming arc of
+        /// the node.
+        ///@param n the node
+        ///@param g the graph
         InArcIt(const Graph& g, const Node& n) {
-          ignore_unused_variable_warning(n);
-          ignore_unused_variable_warning(g);
+          ::lemon::ignore_unused_variable_warning(n);
+          ::lemon::ignore_unused_variable_warning(g);
         }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// Arc -> InArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         InArcIt(const Graph&, const Arc&) { }
         /// Next incoming arc
 
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
+        /// Assign the iterator to the next inarc of the corresponding node.
+        ///
         InArcIt& operator++() { return *this; }
       };
 
-      /// \brief Standard graph map type for the nodes.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the nodes to type \c T.
+      ///
+      /// Reference map of the nodes to type \c T.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&>
@@ -515,7 +508,7 @@
       public:
 
-        /// Constructor
-        explicit NodeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Graph&) { }
+        ///\e
         NodeMap(const Graph&, T) { }
 
@@ -532,8 +525,7 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
@@ -541,9 +533,8 @@
       public:
 
-        /// Constructor
-        explicit ArcMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        ArcMap(const Graph&) { }
+        ///\e
         ArcMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
@@ -558,8 +549,7 @@
       };
 
-      /// \brief Standard graph map type for the edges.
-      ///
-      /// Standard graph map type for the edges.
-      /// It conforms to the ReferenceMap concept.
+      /// Reference map of the edges to type \c T.
+
+      /// Reference map of the edges to type \c T.
       template<class T>
       class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
@@ -567,9 +557,8 @@
       public:
 
-        /// Constructor
-        explicit EdgeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        EdgeMap(const Graph&) { }
+        ///\e
         EdgeMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
@@ -584,121 +573,104 @@
       };
 
-      /// \brief The first node of the edge.
-      ///
-      /// Returns the first node of the given edge.
-      ///
-      /// Edges don't have source and target nodes, however, methods
-      /// u() and v() are used to query the two end-nodes of an edge.
-      /// The orientation of an edge that arises this way is called
-      /// the inherent direction, it is used to define the default
-      /// direction for the corresponding arcs.
+      /// \brief Direct the given edge.
+      ///
+      /// Direct the given edge. The returned arc source
+      /// will be the given node.
+      Arc direct(const Edge&, const Node&) const {
+        return INVALID;
+      }
+
+      /// \brief Direct the given edge.
+      ///
+      /// Direct the given edge. The returned arc
+      /// represents the given edge and the direction comes
+      /// from the bool parameter. The source of the edge and
+      /// the directed arc is the same when the given bool is true.
+      Arc direct(const Edge&, bool) const {
+        return INVALID;
+      }
+
+      /// \brief Returns true if the arc has default orientation.
+      ///
+      /// Returns whether the given directed arc is same orientation as
+      /// the corresponding edge's default orientation.
+      bool direction(Arc) const { return true; }
+
+      /// \brief Returns the opposite directed arc.
+      ///
+      /// Returns the opposite directed arc.
+      Arc oppositeArc(Arc) const { return INVALID; }
+
+      /// \brief Opposite node on an arc
+      ///
+      /// \return The opposite of the given node on the given edge.
+      Node oppositeNode(Node, Edge) const { return INVALID; }
+
+      /// \brief First node of the edge.
+      ///
+      /// \return The first node of the given edge.
+      ///
+      /// Naturally edges don't have direction and thus
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
       /// \sa v()
       /// \sa direction()
       Node u(Edge) const { return INVALID; }
 
-      /// \brief The second node of the edge.
-      ///
-      /// Returns the second node of the given edge.
-      ///
-      /// Edges don't have source and target nodes, however, methods
-      /// u() and v() are used to query the two end-nodes of an edge.
-      /// The orientation of an edge that arises this way is called
-      /// the inherent direction, it is used to define the default
-      /// direction for the corresponding arcs.
+      /// \brief Second node of the edge.
+      ///
+      /// \return The second node of the given edge.
+      ///
+      /// Naturally edges don't have direction and thus
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
       /// \sa u()
       /// \sa direction()
       Node v(Edge) const { return INVALID; }
 
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
+      /// \brief Source node of the directed arc.
       Node source(Arc) const { return INVALID; }
 
-      /// \brief The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
+      /// \brief Target node of the directed arc.
       Node target(Arc) const { return INVALID; }
 
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
+      /// \brief Returns the id of the node.
       int id(Node) const { return -1; }
 
-      /// \brief The ID of the edge.
-      ///
-      /// Returns the ID of the given edge.
+      /// \brief Returns the id of the edge.
       int id(Edge) const { return -1; }
 
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
+      /// \brief Returns the id of the arc.
       int id(Arc) const { return -1; }
 
-      /// \brief The node with the given ID.
-      ///
-      /// Returns the node with the given ID.
-      /// \pre The argument should be a valid node ID in the graph.
+      /// \brief Returns the node with the given id.
+      ///
+      /// \pre The argument should be a valid node id in the graph.
       Node nodeFromId(int) const { return INVALID; }
 
-      /// \brief The edge with the given ID.
-      ///
-      /// Returns the edge with the given ID.
-      /// \pre The argument should be a valid edge ID in the graph.
+      /// \brief Returns the edge with the given id.
+      ///
+      /// \pre The argument should be a valid edge id in the graph.
       Edge edgeFromId(int) const { return INVALID; }
 
-      /// \brief The arc with the given ID.
-      ///
-      /// Returns the arc with the given ID.
-      /// \pre The argument should be a valid arc ID in the graph.
+      /// \brief Returns the arc with the given id.
+      ///
+      /// \pre The argument should be a valid arc id in the graph.
       Arc arcFromId(int) const { return INVALID; }
 
-      /// \brief An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
+      /// \brief Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
 
-      /// \brief An upper bound on the edge IDs.
-      ///
-      /// Returns an upper bound on the edge IDs.
+      /// \brief Returns an upper bound on the edge IDs.
       int maxEdgeId() const { return -1; }
 
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
+      /// \brief Returns an upper bound on the arc IDs.
       int maxArcId() const { return -1; }
-
-      /// \brief The direction of the arc.
-      ///
-      /// Returns \c true if the direction of the given arc is the same as
-      /// the inherent orientation of the represented edge.
-      bool direction(Arc) const { return true; }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc
-      /// represents the given edge and its direction comes
-      /// from the bool parameter. If it is \c true, then the direction
-      /// of the arc is the same as the inherent orientation of the edge.
-      Arc direct(Edge, bool) const {
-        return INVALID;
-      }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc represents the given
-      /// edge and its source node is the given node.
-      Arc direct(Edge, Node) const {
-        return INVALID;
-      }
-
-      /// \brief The oppositely directed arc.
-      ///
-      /// Returns the oppositely directed arc representing the same edge.
-      Arc oppositeArc(Arc) const { return INVALID; }
-
-      /// \brief The opposite node on the edge.
-      ///
-      /// Returns the opposite node on the given edge.
-      Node oppositeNode(Node, Edge) const { return INVALID; }
 
       void first(Node&) const {}
@@ -734,37 +706,45 @@
       int maxId(Arc) const { return -1; }
 
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incident edge iterator.
-      Node baseNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incident edge iterator.
-      Node runningNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given outgoing arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node baseNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given outgoing arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node runningNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incoming arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node baseNode(InArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incoming arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node runningNode(InArcIt) const { return INVALID; }
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node (the source in this case) of the iterator
+      Node baseNode(OutArcIt e) const {
+        return source(e);
+      }
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node (the target in this case) of the
+      /// iterator
+      Node runningNode(OutArcIt e) const {
+        return target(e);
+      }
+
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node (the target in this case) of the iterator
+      Node baseNode(InArcIt e) const {
+        return target(e);
+      }
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node (the source in this case) of the
+      /// iterator
+      Node runningNode(InArcIt e) const {
+        return source(e);
+      }
+
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node of the iterator
+      Node baseNode(IncEdgeIt) const {
+        return INVALID;
+      }
+
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node of the iterator
+      Node runningNode(IncEdgeIt) const {
+        return INVALID;
+      }
 
       template <typename _Graph>
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 1217)
+++ lemon/concepts/graph_components.h	(revision 1257)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,5 +19,5 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concepts of graph components.
+///\brief The concept of graph components.
 
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
@@ -39,5 +39,5 @@
     /// \note This class is a template class so that we can use it to
     /// create graph skeleton classes. The reason for this is that \c Node
-    /// and \c Arc (or \c Edge) types should \e not derive from the same
+    /// and \c Arc (or \c Edge) types should \e not derive from the same 
     /// base class. For \c Node you should instantiate it with character
     /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
@@ -90,8 +90,8 @@
       ///
       /// This operator defines an ordering of the items.
-      /// It makes possible to use graph item types as key types in
+      /// It makes possible to use graph item types as key types in 
       /// associative containers (e.g. \c std::map).
       ///
-      /// \note This operator only has to define some strict ordering of
+      /// \note This operator only have to define some strict ordering of
       /// the items; this order has nothing to do with the iteration
       /// ordering of the items.
@@ -109,5 +109,5 @@
 
           bool b;
-          ignore_unused_variable_warning(b);
+          ::lemon::ignore_unused_variable_warning(b);
 
           b = (ia == ib) && (ia != ib);
@@ -126,5 +126,5 @@
     /// This class describes the base interface of directed graph types.
     /// All digraph %concepts have to conform to this class.
-    /// It just provides types for nodes and arcs and functions
+    /// It just provides types for nodes and arcs and functions 
     /// to get the source and the target nodes of arcs.
     class BaseDigraphComponent {
@@ -290,5 +290,5 @@
             ue = e;
             bool d = graph.direction(e);
-            ignore_unused_variable_warning(d);
+            ::lemon::ignore_unused_variable_warning(d);
           }
         }
@@ -296,170 +296,4 @@
         const _Graph& graph;
       Constraints() {}
-      };
-
-    };
-
-    /// \brief Base skeleton class for undirected bipartite graphs.
-    ///
-    /// This class describes the base interface of undirected
-    /// bipartite graph types.  All bipartite graph %concepts have to
-    /// conform to this class.  It extends the interface of \ref
-    /// BaseGraphComponent with an \c Edge type and functions to get
-    /// the end nodes of edges, to convert from arcs to edges and to
-    /// get both direction of edges.
-    class BaseBpGraphComponent : public BaseGraphComponent {
-    public:
-
-      typedef BaseBpGraphComponent BpGraph;
-
-      typedef BaseDigraphComponent::Node Node;
-      typedef BaseDigraphComponent::Arc Arc;
-
-      /// \brief Class to represent red nodes.
-      ///
-      /// This class represents the red nodes of the graph. The red
-      /// nodes can also be used as normal nodes.
-      class RedNode : public Node {
-        typedef Node Parent;
-
-      public:
-        /// \brief Default constructor.
-        ///
-        /// Default constructor.
-        /// \warning The default constructor is not required to set
-        /// the item to some well-defined value. So you should consider it
-        /// as uninitialized.
-        RedNode() {}
-
-        /// \brief Copy constructor.
-        ///
-        /// Copy constructor.
-        RedNode(const RedNode &) : Parent() {}
-
-        /// \brief Constructor for conversion from \c INVALID.
-        ///
-        /// Constructor for conversion from \c INVALID.
-        /// It initializes the item to be invalid.
-        /// \sa Invalid for more details.
-        RedNode(Invalid) {}
-      };
-
-      /// \brief Class to represent blue nodes.
-      ///
-      /// This class represents the blue nodes of the graph. The blue
-      /// nodes can also be used as normal nodes.
-      class BlueNode : public Node {
-        typedef Node Parent;
-
-      public:
-        /// \brief Default constructor.
-        ///
-        /// Default constructor.
-        /// \warning The default constructor is not required to set
-        /// the item to some well-defined value. So you should consider it
-        /// as uninitialized.
-        BlueNode() {}
-
-        /// \brief Copy constructor.
-        ///
-        /// Copy constructor.
-        BlueNode(const BlueNode &) : Parent() {}
-
-        /// \brief Constructor for conversion from \c INVALID.
-        ///
-        /// Constructor for conversion from \c INVALID.
-        /// It initializes the item to be invalid.
-        /// \sa Invalid for more details.
-        BlueNode(Invalid) {}
-
-        /// \brief Constructor for conversion from a node.
-        ///
-        /// Constructor for conversion from a node. The conversion can
-        /// be invalid, since the Node can be member of the red
-        /// set.
-        BlueNode(const Node&) {}
-      };
-
-      /// \brief Gives back %true for red nodes.
-      ///
-      /// Gives back %true for red nodes.
-      bool red(const Node&) const { return true; }
-
-      /// \brief Gives back %true for blue nodes.
-      ///
-      /// Gives back %true for blue nodes.
-      bool blue(const Node&) const { return true; }
-
-      /// \brief Gives back the red end node of the edge.
-      /// 
-      /// Gives back the red end node of the edge.
-      RedNode redNode(const Edge&) const { return RedNode(); }
-
-      /// \brief Gives back the blue end node of the edge.
-      /// 
-      /// Gives back the blue end node of the edge.
-      BlueNode blueNode(const Edge&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts unsafely the node to red node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      RedNode asRedNodeUnsafe(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. It should be called only if the node is from the red
-      /// partition or INVALID.
-      BlueNode asBlueNodeUnsafe(const Node&) const { return BlueNode(); }
-
-      /// \brief Converts the node to red node object.
-      ///
-      /// This function converts safely the node to red node
-      /// object. If the node is not from the red partition, then it
-      /// returns INVALID.
-      RedNode asRedNode(const Node&) const { return RedNode(); }
-
-      /// \brief Converts the node to blue node object.
-      ///
-      /// This function converts unsafely the node to blue node
-      /// object. If the node is not from the blue partition, then it
-      /// returns INVALID.
-      BlueNode asBlueNode(const Node&) const { return BlueNode(); }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        typedef typename _BpGraph::Node Node;
-        typedef typename _BpGraph::RedNode RedNode;
-        typedef typename _BpGraph::BlueNode BlueNode;
-        typedef typename _BpGraph::Arc Arc;
-        typedef typename _BpGraph::Edge Edge;
-
-        void constraints() {
-          checkConcept<BaseGraphComponent, _BpGraph>();
-          checkConcept<GraphItem<'n'>, RedNode>();
-          checkConcept<GraphItem<'n'>, BlueNode>();
-          {
-            Node n;
-            RedNode rn;
-            BlueNode bn;
-            Node rnan = rn;
-            Node bnan = bn;
-            Edge e;
-            bool b;
-            b = bpgraph.red(rnan);
-            b = bpgraph.blue(bnan);
-            rn = bpgraph.redNode(e);
-            bn = bpgraph.blueNode(e);
-            rn = bpgraph.asRedNodeUnsafe(rnan);
-            bn = bpgraph.asBlueNodeUnsafe(bnan);
-            rn = bpgraph.asRedNode(rnan);
-            bn = bpgraph.asBlueNode(bnan);
-            ignore_unused_variable_warning(b);
-          }
-        }
-
-        const _BpGraph& bpgraph;
       };
 
@@ -535,7 +369,7 @@
 
           nid = digraph.maxNodeId();
-          ignore_unused_variable_warning(nid);
+          ::lemon::ignore_unused_variable_warning(nid);
           eid = digraph.maxArcId();
-          ignore_unused_variable_warning(eid);
+          ::lemon::ignore_unused_variable_warning(eid);
         }
 
@@ -590,5 +424,5 @@
           edge = graph.edgeFromId(ueid);
           ueid = graph.maxEdgeId();
-          ignore_unused_variable_warning(ueid);
+          ::lemon::ignore_unused_variable_warning(ueid);
         }
 
@@ -598,71 +432,7 @@
     };
 
-    /// \brief Skeleton class for \e idable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of \e idable undirected
-    /// bipartite graphs. It extends \ref IDableGraphComponent with
-    /// the core ID functions of undirected bipartite graphs. Beside
-    /// the regular node ids, this class also provides ids within the
-    /// the red and blue sets of the nodes. This concept is part of
-    /// the BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class IDableBpGraphComponent : public IDableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef IDableGraphComponent<BAS> Parent;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-
-      using Parent::id;
-
-      /// \brief Return a unique integer id for the given node in the red set.
-      ///
-      /// Return a unique integer id for the given node in the red set.
-      int id(const RedNode&) const { return -1; }
-
-      /// \brief Return a unique integer id for the given node in the blue set.
-      ///
-      /// Return a unique integer id for the given node in the blue set.
-      int id(const BlueNode&) const { return -1; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// node id in the red set.
-      ///
-      /// Return an integer greater or equal to the maximum
-      /// node id in the red set.
-      int maxRedId() const { return -1; }
-
-      /// \brief Return an integer greater or equal to the maximum
-      /// node id in the blue set.
-      ///
-      /// Return an integer greater or equal to the maximum
-      /// node id in the blue set.
-      int maxBlueId() const { return -1; }
-
-      template <typename _BpGraph>
-      struct Constraints {
-
-        void constraints() {
-          checkConcept<IDableGraphComponent<Base>, _BpGraph>();
-          typename _BpGraph::Node node;
-          typename _BpGraph::RedNode red;
-          typename _BpGraph::BlueNode blue;
-          int rid = bpgraph.id(red);
-          int bid = bpgraph.id(blue);
-          rid = bpgraph.maxRedId();
-          bid = bpgraph.maxBlueId();
-          ignore_unused_variable_warning(rid);
-          ignore_unused_variable_warning(bid);
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
     ///
-    /// This class describes the concept of \c NodeIt, \c ArcIt and
+    /// This class describes the concept of \c NodeIt, \c ArcIt and 
     /// \c EdgeIt subtypes of digraph and graph types.
     template <typename GR, typename Item>
@@ -704,5 +474,5 @@
       /// next item.
       GraphItemIt& operator++() { return *this; }
-
+ 
       /// \brief Equality operator
       ///
@@ -727,6 +497,6 @@
           _GraphItemIt it3 = it1;
           _GraphItemIt it4 = INVALID;
-          ignore_unused_variable_warning(it3);
-          ignore_unused_variable_warning(it4);
+          ::lemon::ignore_unused_variable_warning(it3);
+          ::lemon::ignore_unused_variable_warning(it4);
 
           it2 = ++it1;
@@ -742,13 +512,13 @@
     };
 
-    /// \brief Concept class for \c InArcIt, \c OutArcIt and
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
     /// \c IncEdgeIt types.
     ///
-    /// This class describes the concept of \c InArcIt, \c OutArcIt
+    /// This class describes the concept of \c InArcIt, \c OutArcIt 
     /// and \c IncEdgeIt subtypes of digraph and graph types.
     ///
     /// \note Since these iterator classes do not inherit from the same
     /// base class, there is an additional template parameter (selector)
-    /// \c sel. For \c InArcIt you should instantiate it with character
+    /// \c sel. For \c InArcIt you should instantiate it with character 
     /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
     template <typename GR,
@@ -771,8 +541,8 @@
       GraphIncIt(const GraphIncIt& it) : Item(it) {}
 
-      /// \brief Constructor that sets the iterator to the first
+      /// \brief Constructor that sets the iterator to the first 
       /// incoming or outgoing arc.
       ///
-      /// Constructor that sets the iterator to the first arc
+      /// Constructor that sets the iterator to the first arc 
       /// incoming to or outgoing from the given node.
       explicit GraphIncIt(const GR&, const Base&) {}
@@ -818,6 +588,6 @@
           _GraphIncIt it3 = it1;
           _GraphIncIt it4 = INVALID;
-          ignore_unused_variable_warning(it3);
-          ignore_unused_variable_warning(it4);
+          ::lemon::ignore_unused_variable_warning(it3);
+          ::lemon::ignore_unused_variable_warning(it4);
 
           it2 = ++it1;
@@ -876,13 +646,13 @@
       void next(Arc&) const {}
 
-      /// \brief Return the first arc incoming to the given node.
-      ///
-      /// This function gives back the first arc incoming to the
+      /// \brief Return the first arc incomming to the given node.
+      ///
+      /// This function gives back the first arc incomming to the
       /// given node.
       void firstIn(Arc&, const Node&) const {}
 
-      /// \brief Return the next arc incoming to the given node.
-      ///
-      /// This function gives back the next arc incoming to the
+      /// \brief Return the next arc incomming to the given node.
+      ///
+      /// This function gives back the next arc incomming to the
       /// given node.
       void nextIn(Arc&) const {}
@@ -1001,5 +771,5 @@
             n = digraph.baseNode(oait);
             n = digraph.runningNode(oait);
-            ignore_unused_variable_warning(n);
+            ::lemon::ignore_unused_variable_warning(n);
           }
         }
@@ -1049,7 +819,7 @@
       /// \brief Return the first edge incident to the given node.
       ///
-      /// This function gives back the first edge incident to the given
+      /// This function gives back the first edge incident to the given 
       /// node. The bool parameter gives back the direction for which the
-      /// source node of the directed arc representing the edge is the
+      /// source node of the directed arc representing the edge is the 
       /// given node.
       void firstInc(Edge&, bool&, const Node&) const {}
@@ -1058,5 +828,5 @@
       /// given node.
       ///
-      /// This function gives back the next edge incident to the given
+      /// This function gives back the next edge incident to the given 
       /// node. The bool parameter should be used as \c firstInc() use it.
       void nextInc(Edge&, bool&) const {}
@@ -1135,95 +905,4 @@
     };
 
-    /// \brief Skeleton class for iterable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of iterable undirected
-    /// bipartite graphs. It extends \ref IterableGraphComponent with
-    /// the core iterable interface of undirected bipartite graphs.
-    /// This concept is part of the BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class IterableBpGraphComponent : public IterableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-      typedef typename Base::Arc Arc;
-      typedef typename Base::Edge Edge;
-      
-      typedef IterableBpGraphComponent BpGraph;
-
-      using IterableGraphComponent<BAS>::first;
-      using IterableGraphComponent<BAS>::next;
-
-      /// \name Base Iteration
-      ///
-      /// This interface provides functions for iteration on red and blue nodes.
-      ///
-      /// @{
-
-      /// \brief Return the first red node.
-      ///
-      /// This function gives back the first red node in the iteration order.
-      void first(RedNode&) const {}
-
-      /// \brief Return the next red node.
-      ///
-      /// This function gives back the next red node in the iteration order.
-      void next(RedNode&) const {}
-
-      /// \brief Return the first blue node.
-      ///
-      /// This function gives back the first blue node in the iteration order.
-      void first(BlueNode&) const {}
-
-      /// \brief Return the next blue node.
-      ///
-      /// This function gives back the next blue node in the iteration order.
-      void next(BlueNode&) const {}
-
-
-      /// @}
-
-      /// \name Class Based Iteration
-      ///
-      /// This interface provides iterator classes for red and blue nodes.
-      ///
-      /// @{
-
-      /// \brief This iterator goes through each red node.
-      ///
-      /// This iterator goes through each red node.
-      typedef GraphItemIt<BpGraph, RedNode> RedNodeIt;
-
-      /// \brief This iterator goes through each blue node.
-      ///
-      /// This iterator goes through each blue node.
-      typedef GraphItemIt<BpGraph, BlueNode> BlueNodeIt;
-
-      /// @}
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<IterableGraphComponent<Base>, _BpGraph>();
-
-          typename _BpGraph::RedNode rn(INVALID);
-          bpgraph.first(rn);
-          bpgraph.next(rn); 
-          typename _BpGraph::BlueNode bn(INVALID);
-          bpgraph.first(bn);
-          bpgraph.next(bn);
-
-          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::RedNode>,
-            typename _BpGraph::RedNodeIt>();
-          checkConcept<GraphItemIt<_BpGraph, typename _BpGraph::BlueNode>,
-            typename _BpGraph::BlueNodeIt>();
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Skeleton class for alterable directed graphs.
     ///
@@ -1251,12 +930,9 @@
       ArcNotifier;
 
-      mutable NodeNotifier node_notifier;
-      mutable ArcNotifier arc_notifier;
-
       /// \brief Return the node alteration notifier.
       ///
       /// This function gives back the node alteration notifier.
       NodeNotifier& notifier(Node) const {
-        return node_notifier;
+         return NodeNotifier();
       }
 
@@ -1265,5 +941,5 @@
       /// This function gives back the arc alteration notifier.
       ArcNotifier& notifier(Arc) const {
-        return arc_notifier;
+        return ArcNotifier();
       }
 
@@ -1278,6 +954,6 @@
             = digraph.notifier(typename _Digraph::Arc());
 
-          ignore_unused_variable_warning(nn);
-          ignore_unused_variable_warning(en);
+          ::lemon::ignore_unused_variable_warning(nn);
+          ::lemon::ignore_unused_variable_warning(en);
         }
 
@@ -1301,5 +977,4 @@
 
       typedef BAS Base;
-      typedef AlterableDigraphComponent<Base> Parent;
       typedef typename Base::Edge Edge;
 
@@ -1309,13 +984,9 @@
       EdgeNotifier;
 
-      mutable EdgeNotifier edge_notifier;
-
-      using Parent::notifier;
-
       /// \brief Return the edge alteration notifier.
       ///
       /// This function gives back the edge alteration notifier.
       EdgeNotifier& notifier(Edge) const {
-        return edge_notifier;
+        return EdgeNotifier();
       }
 
@@ -1326,5 +997,5 @@
           typename _Graph::EdgeNotifier& uen
             = graph.notifier(typename _Graph::Edge());
-          ignore_unused_variable_warning(uen);
+          ::lemon::ignore_unused_variable_warning(uen);
         }
 
@@ -1334,70 +1005,8 @@
     };
 
-    /// \brief Skeleton class for alterable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of alterable undirected
-    /// bipartite graphs. It extends \ref AlterableGraphComponent with
-    /// the alteration notifier interface of bipartite graphs. It
-    /// implements an observer-notifier pattern for the red and blue
-    /// nodes. More obsevers can be registered into the notifier and
-    /// whenever an alteration occured in the graph all the observers
-    /// will be notified about it.
-    template <typename BAS = BaseBpGraphComponent>
-    class AlterableBpGraphComponent : public AlterableGraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
-      typedef AlterableGraphComponent<Base> Parent;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-
-
-      /// Red node alteration notifier class.
-      typedef AlterationNotifier<AlterableBpGraphComponent, RedNode>
-      RedNodeNotifier;
-
-      /// Blue node alteration notifier class.
-      typedef AlterationNotifier<AlterableBpGraphComponent, BlueNode>
-      BlueNodeNotifier;
-
-      mutable RedNodeNotifier red_node_notifier;
-      mutable BlueNodeNotifier blue_node_notifier;
-
-      using Parent::notifier;
-
-      /// \brief Return the red node alteration notifier.
-      ///
-      /// This function gives back the red node alteration notifier.
-      RedNodeNotifier& notifier(RedNode) const {
-        return red_node_notifier;
-      }
-
-      /// \brief Return the blue node alteration notifier.
-      ///
-      /// This function gives back the blue node alteration notifier.
-      BlueNodeNotifier& notifier(BlueNode) const {
-        return blue_node_notifier;
-      }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<AlterableGraphComponent<Base>, _BpGraph>();
-          typename _BpGraph::RedNodeNotifier& rnn
-            = bpgraph.notifier(typename _BpGraph::RedNode());
-          typename _BpGraph::BlueNodeNotifier& bnn
-            = bpgraph.notifier(typename _BpGraph::BlueNode());
-          ignore_unused_variable_warning(rnn);
-          ignore_unused_variable_warning(bnn);
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Concept class for standard graph maps.
     ///
     /// This class describes the concept of standard graph maps, i.e.
-    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
+    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
     /// graph types, which can be used for associating data to graph items.
     /// The standard graph maps must conform to the ReferenceMap concept.
@@ -1454,5 +1063,5 @@
           _Map m1(g);
           _Map m2(g,t);
-
+          
           // Copy constructor
           // _Map m3(m);
@@ -1462,7 +1071,7 @@
           // m3 = cmap;
 
-          ignore_unused_variable_warning(m1);
-          ignore_unused_variable_warning(m2);
-          // ignore_unused_variable_warning(m3);
+          ::lemon::ignore_unused_variable_warning(m1);
+          ::lemon::ignore_unused_variable_warning(m2);
+          // ::lemon::ignore_unused_variable_warning(m3);
         }
 
@@ -1478,5 +1087,5 @@
     ///
     /// This class describes the interface of mappable directed graphs.
-    /// It extends \ref BaseDigraphComponent with the standard digraph
+    /// It extends \ref BaseDigraphComponent with the standard digraph 
     /// map classes, namely \c NodeMap and \c ArcMap.
     /// This concept is part of the Digraph concept.
@@ -1616,5 +1225,5 @@
     ///
     /// This class describes the interface of mappable undirected graphs.
-    /// It extends \ref MappableDigraphComponent with the standard graph
+    /// It extends \ref MappableDigraphComponent with the standard graph 
     /// map class for edges (\c EdgeMap).
     /// This concept is part of the Graph concept.
@@ -1699,152 +1308,8 @@
     };
 
-    /// \brief Skeleton class for mappable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of mappable undirected
-    /// bipartite graphs.  It extends \ref MappableGraphComponent with
-    /// the standard graph map class for red and blue nodes (\c
-    /// RedNodeMap and BlueNodeMap). This concept is part of the
-    /// BpGraph concept.
-    template <typename BAS = BaseBpGraphComponent>
-    class MappableBpGraphComponent : public MappableGraphComponent<BAS>  {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-
-      typedef MappableBpGraphComponent BpGraph;
-
-      /// \brief Standard graph map for the red nodes.
-      ///
-      /// Standard graph map for the red nodes.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class RedNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
-        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
-
-      public:
-        /// \brief Construct a new map.
-        ///
-        /// Construct a new map for the graph.
-        explicit RedNodeMap(const MappableBpGraphComponent& graph)
-          : Parent(graph) {}
-
-        /// \brief Construct a new map with default value.
-        ///
-        /// Construct a new map for the graph and initalize the values.
-        RedNodeMap(const MappableBpGraphComponent& graph, const V& value)
-          : Parent(graph, value) {}
-
-      private:
-        /// \brief Copy constructor.
-        ///
-        /// Copy Constructor.
-        RedNodeMap(const RedNodeMap& nm) : Parent(nm) {}
-
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
-        template <typename CMap>
-        RedNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
-          return *this;
-        }
-
-      };
-
-      /// \brief Standard graph map for the blue nodes.
-      ///
-      /// Standard graph map for the blue nodes.
-      /// It conforms to the ReferenceMap concept.
-      template <typename V>
-      class BlueNodeMap : public GraphMap<MappableBpGraphComponent, Node, V> {
-        typedef GraphMap<MappableBpGraphComponent, Node, V> Parent;
-
-      public:
-        /// \brief Construct a new map.
-        ///
-        /// Construct a new map for the graph.
-        explicit BlueNodeMap(const MappableBpGraphComponent& graph)
-          : Parent(graph) {}
-
-        /// \brief Construct a new map with default value.
-        ///
-        /// Construct a new map for the graph and initalize the values.
-        BlueNodeMap(const MappableBpGraphComponent& graph, const V& value)
-          : Parent(graph, value) {}
-
-      private:
-        /// \brief Copy constructor.
-        ///
-        /// Copy Constructor.
-        BlueNodeMap(const BlueNodeMap& nm) : Parent(nm) {}
-
-        /// \brief Assignment operator.
-        ///
-        /// Assignment operator.
-        template <typename CMap>
-        BlueNodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
-          return *this;
-        }
-
-      };
-
-
-      template <typename _BpGraph>
-      struct Constraints {
-
-        struct Dummy {
-          int value;
-          Dummy() : value(0) {}
-          Dummy(int _v) : value(_v) {}
-        };
-
-        void constraints() {
-          checkConcept<MappableGraphComponent<Base>, _BpGraph>();
-
-          { // int map test
-            typedef typename _BpGraph::template RedNodeMap<int>
-              IntRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, int>,
-              IntRedNodeMap >();
-          } { // bool map test
-            typedef typename _BpGraph::template RedNodeMap<bool>
-              BoolRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, bool>,
-              BoolRedNodeMap >();
-          } { // Dummy map test
-            typedef typename _BpGraph::template RedNodeMap<Dummy>
-              DummyRedNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::RedNode, Dummy>,
-              DummyRedNodeMap >();
-          }
-
-          { // int map test
-            typedef typename _BpGraph::template BlueNodeMap<int>
-              IntBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, int>,
-              IntBlueNodeMap >();
-          } { // bool map test
-            typedef typename _BpGraph::template BlueNodeMap<bool>
-              BoolBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, bool>,
-              BoolBlueNodeMap >();
-          } { // Dummy map test
-            typedef typename _BpGraph::template BlueNodeMap<Dummy>
-              DummyBlueNodeMap;
-            checkConcept<GraphMap<_BpGraph, typename _BpGraph::BlueNode, Dummy>,
-              DummyBlueNodeMap >();
-          }
-        }
-
-        const _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Skeleton class for extendable directed graphs.
     ///
     /// This class describes the interface of extendable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for adding
+    /// It extends \ref BaseDigraphComponent with functions for adding 
     /// nodes and arcs to the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -1891,5 +1356,5 @@
     ///
     /// This class describes the interface of extendable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for adding
+    /// It extends \ref BaseGraphComponent with functions for adding 
     /// nodes and edges to the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -1933,67 +1398,8 @@
     };
 
-    /// \brief Skeleton class for extendable undirected bipartite graphs.
-    ///
-    /// This class describes the interface of extendable undirected
-    /// bipartite graphs. It extends \ref BaseGraphComponent with
-    /// functions for adding nodes and edges to the graph. This
-    /// concept requires \ref AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ExtendableBpGraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::RedNode RedNode;
-      typedef typename Base::BlueNode BlueNode;
-      typedef typename Base::Edge Edge;
-
-      /// \brief Add a new red node to the digraph.
-      ///
-      /// This function adds a red new node to the digraph.
-      RedNode addRedNode() {
-        return INVALID;
-      }
-
-      /// \brief Add a new blue node to the digraph.
-      ///
-      /// This function adds a blue new node to the digraph.
-      BlueNode addBlueNode() {
-        return INVALID;
-      }
-
-      /// \brief Add a new edge connecting the given two nodes.
-      ///
-      /// This function adds a new edge connecting the given two nodes
-      /// of the graph. The first node has to be a red node, and the
-      /// second one a blue node.
-      Edge addEdge(const RedNode&, const BlueNode&) {
-        return INVALID;
-      }
-      Edge addEdge(const BlueNode&, const RedNode&) {
-        return INVALID;
-      }
-
-      template <typename _BpGraph>
-      struct Constraints {
-        void constraints() {
-          checkConcept<Base, _BpGraph>();
-          typename _BpGraph::RedNode red_node;
-          typename _BpGraph::BlueNode blue_node;
-          red_node = bpgraph.addRedNode();
-          blue_node = bpgraph.addBlueNode();
-          typename _BpGraph::Edge edge;
-          edge = bpgraph.addEdge(red_node, blue_node);
-          edge = bpgraph.addEdge(blue_node, red_node);
-        }
-
-        _BpGraph& bpgraph;
-      };
-    };
-
     /// \brief Skeleton class for erasable directed graphs.
     ///
     /// This class describes the interface of erasable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for removing
+    /// It extends \ref BaseDigraphComponent with functions for removing 
     /// nodes and arcs from the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -2008,5 +1414,5 @@
       /// \brief Erase a node from the digraph.
       ///
-      /// This function erases the given node from the digraph and all arcs
+      /// This function erases the given node from the digraph and all arcs 
       /// connected to the node.
       void erase(const Node&) {}
@@ -2035,5 +1441,5 @@
     ///
     /// This class describes the interface of erasable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for removing
+    /// It extends \ref BaseGraphComponent with functions for removing 
     /// nodes and edges from the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -2071,13 +1477,4 @@
       };
     };
-
-    /// \brief Skeleton class for erasable undirected graphs.
-    ///
-    /// This class describes the interface of erasable undirected
-    /// bipartite graphs. It extends \ref BaseBpGraphComponent with
-    /// functions for removing nodes and edges from the graph. This
-    /// concept requires \ref AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ErasableBpGraphComponent : public ErasableGraphComponent<BAS> {};
 
     /// \brief Skeleton class for clearable directed graphs.
@@ -2117,14 +1514,25 @@
     /// This concept requires \ref AlterableGraphComponent.
     template <typename BAS = BaseGraphComponent>
-    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {};
-
-    /// \brief Skeleton class for clearable undirected biparite graphs.
-    ///
-    /// This class describes the interface of clearable undirected
-    /// bipartite graphs. It extends \ref BaseBpGraphComponent with a
-    /// function for clearing the graph.  This concept requires \ref
-    /// AlterableBpGraphComponent.
-    template <typename BAS = BaseBpGraphComponent>
-    class ClearableBpGraphComponent : public ClearableGraphComponent<BAS> {};
+    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
+    public:
+
+      typedef BAS Base;
+
+      /// \brief Erase all nodes and edges from the graph.
+      ///
+      /// This function erases all nodes and edges from the graph.
+      void clear() {}
+
+      template <typename _Graph>
+      struct Constraints {
+        void constraints() {
+          checkConcept<Base, _Graph>();
+          graph.clear();
+        }
+
+        _Graph& graph;
+        Constraints() {}
+      };
+    };
 
   }
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 1127)
+++ lemon/concepts/heap.h	(revision 1257)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,11 +17,11 @@
  */
 
-#ifndef LEMON_CONCEPTS_HEAP_H
-#define LEMON_CONCEPTS_HEAP_H
-
 ///\ingroup concept
 ///\file
 ///\brief The concept of heaps.
 
+#ifndef LEMON_CONCEPTS_HEAP_H
+#define LEMON_CONCEPTS_HEAP_H
+
 #include <lemon/core.h>
 #include <lemon/concept_check.h>
@@ -36,25 +36,19 @@
     /// \brief The heap concept.
     ///
-    /// This concept class describes the main interface of heaps.
-    /// The various \ref heaps "heap structures" are efficient
-    /// implementations of the abstract data type \e priority \e queue.
-    /// They store items with specified values called \e priorities
-    /// in such a way that finding and removing the item with minimum
-    /// priority are efficient. The basic operations are adding and
-    /// erasing items, changing the priority of an item, etc.
+    /// Concept class describing the main interface of heaps. A \e heap
+    /// is a data structure for storing items with specified values called
+    /// \e priorities in such a way that finding the item with minimum
+    /// priority is efficient. In a heap one can change the priority of an
+    /// item, add or erase an item, etc.
     ///
-    /// Heaps are crucial in several algorithms, such as Dijkstra and Prim.
-    /// Any class that conforms to this concept can be used easily in such
-    /// algorithms.
-    ///
-    /// \tparam PR Type of the priorities of the items.
-    /// \tparam IM A read-writable item map with \c int values, used
+    /// \tparam PR Type of the priority of the items.
+    /// \tparam IM A read and writable item map with int values, used
     /// internally to handle the cross references.
-    /// \tparam CMP A functor class for comparing the priorities.
+    /// \tparam Comp A functor class for the ordering of the priorities.
     /// The default is \c std::less<PR>.
 #ifdef DOXYGEN
-    template <typename PR, typename IM, typename CMP>
+    template <typename PR, typename IM, typename Comp = std::less<PR> >
 #else
-    template <typename PR, typename IM, typename CMP = std::less<PR> >
+    template <typename PR, typename IM>
 #endif
     class Heap {
@@ -71,6 +65,7 @@
       ///
       /// Each item has a state associated to it. It can be "in heap",
-      /// "pre-heap" or "post-heap". The latter two are indifferent from the
-      /// heap's point of view, but may be useful to the user.
+      /// "pre heap" or "post heap". The later two are indifferent
+      /// from the point of view of the heap, but may be useful for
+      /// the user.
       ///
       /// The item-int map must be initialized in such way that it assigns
@@ -78,148 +73,99 @@
       enum State {
         IN_HEAP = 0,    ///< = 0. The "in heap" state constant.
-        PRE_HEAP = -1,  ///< = -1. The "pre-heap" state constant.
-        POST_HEAP = -2  ///< = -2. The "post-heap" state constant.
+        PRE_HEAP = -1,  ///< = -1. The "pre heap" state constant.
+        POST_HEAP = -2  ///< = -2. The "post heap" state constant.
       };
 
-      /// \brief Constructor.
-      ///
-      /// Constructor.
+      /// \brief The constructor.
+      ///
+      /// The constructor.
       /// \param map A map that assigns \c int values to keys of type
       /// \c Item. It is used internally by the heap implementations to
       /// handle the cross references. The assigned value must be
-      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
-#ifdef DOXYGEN
+      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
       explicit Heap(ItemIntMap &map) {}
-#else
-      explicit Heap(ItemIntMap&) {}
-#endif
-
-      /// \brief Constructor.
-      ///
-      /// Constructor.
-      /// \param map A map that assigns \c int values to keys of type
-      /// \c Item. It is used internally by the heap implementations to
-      /// handle the cross references. The assigned value must be
-      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
-      /// \param comp The function object used for comparing the priorities.
-#ifdef DOXYGEN
-      explicit Heap(ItemIntMap &map, const CMP &comp) {}
-#else
-      explicit Heap(ItemIntMap&, const CMP&) {}
-#endif
 
       /// \brief The number of items stored in the heap.
       ///
-      /// This function returns the number of items stored in the heap.
+      /// Returns the number of items stored in the heap.
       int size() const { return 0; }
 
-      /// \brief Check if the heap is empty.
-      ///
-      /// This function returns \c true if the heap is empty.
+      /// \brief Checks if the heap is empty.
+      ///
+      /// Returns \c true if the heap is empty.
       bool empty() const { return false; }
 
-      /// \brief Make the heap empty.
-      ///
-      /// This functon makes the heap empty.
-      /// It does not change the cross reference map. If you want to reuse
-      /// a heap that is not surely empty, you should first clear it and
-      /// then you should set the cross reference map to \c PRE_HEAP
-      /// for each item.
-      void clear() {}
-
-      /// \brief Insert an item into the heap with the given priority.
-      ///
-      /// This function inserts the given item into the heap with the
-      /// given priority.
+      /// \brief Makes the heap empty.
+      ///
+      /// Makes the heap empty.
+      void clear();
+
+      /// \brief Inserts an item into the heap with the given priority.
+      ///
+      /// Inserts the given item into the heap with the given priority.
       /// \param i The item to insert.
       /// \param p The priority of the item.
-      /// \pre \e i must not be stored in the heap.
-#ifdef DOXYGEN
       void push(const Item &i, const Prio &p) {}
-#else
-      void push(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Return the item having minimum priority.
-      ///
-      /// This function returns the item having minimum priority.
+
+      /// \brief Returns the item having minimum priority.
+      ///
+      /// Returns the item having minimum priority.
       /// \pre The heap must be non-empty.
-      Item top() const { return Item(); }
+      Item top() const {}
 
       /// \brief The minimum priority.
       ///
-      /// This function returns the minimum priority.
+      /// Returns the minimum priority.
       /// \pre The heap must be non-empty.
-      Prio prio() const { return Prio(); }
-
-      /// \brief Remove the item having minimum priority.
-      ///
-      /// This function removes the item having minimum priority.
+      Prio prio() const {}
+
+      /// \brief Removes the item having minimum priority.
+      ///
+      /// Removes the item having minimum priority.
       /// \pre The heap must be non-empty.
       void pop() {}
 
-      /// \brief Remove the given item from the heap.
-      ///
-      /// This function removes the given item from the heap if it is
-      /// already stored.
+      /// \brief Removes an item from the heap.
+      ///
+      /// Removes the given item from the heap if it is already stored.
       /// \param i The item to delete.
-      /// \pre \e i must be in the heap.
-#ifdef DOXYGEN
       void erase(const Item &i) {}
-#else
-      void erase(const Item&) {}
-#endif
-
-      /// \brief The priority of the given item.
-      ///
-      /// This function returns the priority of the given item.
-      /// \param i The item.
-      /// \pre \e i must be in the heap.
-#ifdef DOXYGEN
+
+      /// \brief The priority of an item.
+      ///
+      /// Returns the priority of the given item.
+      /// \param i The item.
+      /// \pre \c i must be in the heap.
       Prio operator[](const Item &i) const {}
-#else
-      Prio operator[](const Item&) const { return Prio(); }
-#endif
-
-      /// \brief Set the priority of an item or insert it, if it is
+
+      /// \brief Sets the priority of an item or inserts it, if it is
       /// not stored in the heap.
       ///
       /// This method sets the priority of the given item if it is
-      /// already stored in the heap. Otherwise it inserts the given
-      /// item into the heap with the given priority.
+      /// already stored in the heap.
+      /// Otherwise it inserts the given item with the given priority.
       ///
       /// \param i The item.
       /// \param p The priority.
-#ifdef DOXYGEN
       void set(const Item &i, const Prio &p) {}
-#else
-      void set(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Decrease the priority of an item to the given value.
-      ///
-      /// This function decreases the priority of an item to the given value.
+
+      /// \brief Decreases the priority of an item to the given value.
+      ///
+      /// Decreases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
-      /// \pre \e i must be stored in the heap with priority at least \e p.
-#ifdef DOXYGEN
+      /// \pre \c i must be stored in the heap with priority at least \c p.
       void decrease(const Item &i, const Prio &p) {}
-#else
-      void decrease(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Increase the priority of an item to the given value.
-      ///
-      /// This function increases the priority of an item to the given value.
+
+      /// \brief Increases the priority of an item to the given value.
+      ///
+      /// Increases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
-      /// \pre \e i must be stored in the heap with priority at most \e p.
-#ifdef DOXYGEN
+      /// \pre \c i must be stored in the heap with priority at most \c p.
       void increase(const Item &i, const Prio &p) {}
-#else
-      void increase(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Return the state of an item.
+
+      /// \brief Returns if an item is in, has already been in, or has
+      /// never been in the heap.
       ///
       /// This method returns \c PRE_HEAP if the given item has never
@@ -229,22 +175,14 @@
       /// to the heap again.
       /// \param i The item.
-#ifdef DOXYGEN
       State state(const Item &i) const {}
-#else
-      State state(const Item&) const { return PRE_HEAP; }
-#endif
-
-      /// \brief Set the state of an item in the heap.
-      ///
-      /// This function sets the state of the given item in the heap.
-      /// It can be used to manually clear the heap when it is important
-      /// to achive better time complexity.
+
+      /// \brief Sets the state of an item in the heap.
+      ///
+      /// Sets the state of the given item in the heap. It can be used
+      /// to manually clear the heap when it is important to achive the
+      /// better time complexity.
       /// \param i The item.
       /// \param st The state. It should not be \c IN_HEAP.
-#ifdef DOXYGEN
       void state(const Item& i, State st) {}
-#else
-      void state(const Item&, State) {}
-#endif
 
 
@@ -261,6 +199,6 @@
           item=Item();
           prio=Prio();
-          ignore_unused_variable_warning(item);
-          ignore_unused_variable_warning(prio);
+          ::lemon::ignore_unused_variable_warning(item);
+          ::lemon::ignore_unused_variable_warning(prio);
 
           OwnItem own_item;
@@ -269,17 +207,17 @@
           own_item=Item();
           own_prio=Prio();
-          ignore_unused_variable_warning(own_item);
-          ignore_unused_variable_warning(own_prio);
-          ignore_unused_variable_warning(own_state);
+          ::lemon::ignore_unused_variable_warning(own_item);
+          ::lemon::ignore_unused_variable_warning(own_prio);
+          ::lemon::ignore_unused_variable_warning(own_state);
 
           _Heap heap1(map);
           _Heap heap2 = heap1;
-          ignore_unused_variable_warning(heap1);
-          ignore_unused_variable_warning(heap2);
+          ::lemon::ignore_unused_variable_warning(heap1);
+          ::lemon::ignore_unused_variable_warning(heap2);
 
           int s = heap.size();
-          ignore_unused_variable_warning(s);
+          ::lemon::ignore_unused_variable_warning(s);
           bool e = heap.empty();
-          ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(e);
 
           prio = heap.prio();
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 1157)
+++ lemon/concepts/maps.h	(revision 1257)
@@ -61,8 +61,8 @@
           own_val = m[own_key];
 
-          ignore_unused_variable_warning(key);
-          ignore_unused_variable_warning(val);
-          ignore_unused_variable_warning(own_key);
-          ignore_unused_variable_warning(own_val);
+          ::lemon::ignore_unused_variable_warning(key);
+          ::lemon::ignore_unused_variable_warning(val);
+          ::lemon::ignore_unused_variable_warning(own_key);
+          ::lemon::ignore_unused_variable_warning(own_val);
         }
         const Key& key;
@@ -101,8 +101,8 @@
           m.set(own_key, own_val);
 
-          ignore_unused_variable_warning(key);
-          ignore_unused_variable_warning(val);
-          ignore_unused_variable_warning(own_key);
-          ignore_unused_variable_warning(own_val);
+          ::lemon::ignore_unused_variable_warning(key);
+          ::lemon::ignore_unused_variable_warning(val);
+          ::lemon::ignore_unused_variable_warning(own_key);
+          ::lemon::ignore_unused_variable_warning(own_val);
         }
         const Key& key;
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 1127)
+++ lemon/concepts/path.h	(revision 1257)
@@ -19,5 +19,5 @@
 ///\ingroup concept
 ///\file
-///\brief The concept of paths
+///\brief Classes for representing paths in digraphs.
 ///
 
@@ -39,20 +39,11 @@
     /// A skeleton structure for representing directed paths in a
     /// digraph.
-    /// In a sense, a path can be treated as a list of arcs.
-    /// LEMON path types just store this list. As a consequence, they cannot
-    /// enumerate the nodes on the path directly and a zero length path
-    /// cannot store its source node.
-    ///
-    /// The arcs of a path should be stored in the order of their directions,
-    /// i.e. the target node of each arc should be the same as the source
-    /// node of the next arc. This consistency could be checked using
-    /// \ref checkPath().
-    /// The source and target nodes of a (consistent) path can be obtained
-    /// using \ref pathSource() and \ref pathTarget().
-    ///
-    /// A path can be constructed from another path of any type using the
-    /// copy constructor or the assignment operator.
-    ///
     /// \tparam GR The digraph type in which the path is.
+    ///
+    /// In a sense, the path can be treated as a list of arcs. The
+    /// lemon path type stores just this list. As a consequence it
+    /// cannot enumerate the nodes in the path and the zero length
+    /// paths cannot store the source.
+    ///
     template <typename GR>
     class Path {
@@ -69,16 +60,16 @@
       Path() {}
 
-      /// \brief Template copy constructor
+      /// \brief Template constructor
       template <typename CPath>
       Path(const CPath& cpath) {}
 
-      /// \brief Template assigment operator
+      /// \brief Template assigment
       template <typename CPath>
       Path& operator=(const CPath& cpath) {
-        ignore_unused_variable_warning(cpath);
+        ::lemon::ignore_unused_variable_warning(cpath);
         return *this;
       }
 
-      /// Length of the path, i.e. the number of arcs on the path.
+      /// Length of the path ie. the number of arcs in the path.
       int length() const { return 0;}
 
@@ -89,7 +80,7 @@
       void clear() {}
 
-      /// \brief LEMON style iterator for enumerating the arcs of a path.
+      /// \brief LEMON style iterator for path arcs
       ///
-      /// LEMON style iterator class for enumerating the arcs of a path.
+      /// This class is used to iterate on the arcs of the paths.
       class ArcIt {
       public:
@@ -98,8 +89,8 @@
         /// Invalid constructor
         ArcIt(Invalid) {}
-        /// Sets the iterator to the first arc of the given path
+        /// Constructor for first arc
         ArcIt(const Path &) {}
 
-        /// Conversion to \c Arc
+        /// Conversion to Arc
         operator Arc() const { return INVALID; }
 
@@ -136,10 +127,10 @@
           e = (i < ii);
 
-          ignore_unused_variable_warning(l);
-          ignore_unused_variable_warning(pp);
-          ignore_unused_variable_warning(e);
-          ignore_unused_variable_warning(id);
-          ignore_unused_variable_warning(ii);
-          ignore_unused_variable_warning(ed);
+          ::lemon::ignore_unused_variable_warning(l);
+          ::lemon::ignore_unused_variable_warning(pp);
+          ::lemon::ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(id);
+          ::lemon::ignore_unused_variable_warning(ii);
+          ::lemon::ignore_unused_variable_warning(ed);
         }
       };
@@ -163,8 +154,8 @@
           e = (i != INVALID);
 
-          ignore_unused_variable_warning(l);
-          ignore_unused_variable_warning(e);
-          ignore_unused_variable_warning(id);
-          ignore_unused_variable_warning(ed);
+          ::lemon::ignore_unused_variable_warning(l);
+          ::lemon::ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(id);
+          ::lemon::ignore_unused_variable_warning(ed);
         }
         _Path& p;
@@ -189,8 +180,8 @@
           e = (i != INVALID);
 
-          ignore_unused_variable_warning(l);
-          ignore_unused_variable_warning(e);
-          ignore_unused_variable_warning(id);
-          ignore_unused_variable_warning(ed);
+          ::lemon::ignore_unused_variable_warning(l);
+          ::lemon::ignore_unused_variable_warning(e);
+          ::lemon::ignore_unused_variable_warning(id);
+          ::lemon::ignore_unused_variable_warning(ed);
         }
         _Path& p;
@@ -204,16 +195,22 @@
     ///
     /// A skeleton structure for path dumpers. The path dumpers are
-    /// the generalization of the paths, they can enumerate the arcs
-    /// of the path either in forward or in backward order.
-    /// These classes are typically not used directly, they are rather
-    /// used to be assigned to a real path type.
+    /// the generalization of the paths. The path dumpers can
+    /// enumerate the arcs of the path wheter in forward or in
+    /// backward order.  In most time these classes are not used
+    /// directly rather it used to assign a dumped class to a real
+    /// path type.
     ///
     /// The main purpose of this concept is that the shortest path
-    /// algorithms can enumerate the arcs easily in reverse order.
-    /// In LEMON, such algorithms give back a (reverse) path dumper that
-    /// can be assigned to a real path. The dumpers can be implemented as
+    /// algorithms can enumerate easily the arcs in reverse order.
+    /// If we would like to give back a real path from these
+    /// algorithms then we should create a temporarly path object. In
+    /// LEMON such algorithms gives back a path dumper what can
+    /// assigned to a real path and the dumpers can be implemented as
     /// an adaptor class to the predecessor map.
     ///
     /// \tparam GR The digraph type in which the path is.
+    ///
+    /// The paths can be constructed from any path type by a
+    /// template constructor or a template assignment operator.
     template <typename GR>
     class PathDumper {
@@ -225,5 +222,5 @@
       typedef typename Digraph::Arc Arc;
 
-      /// Length of the path, i.e. the number of arcs on the path.
+      /// Length of the path ie. the number of arcs in the path.
       int length() const { return 0;}
 
@@ -233,12 +230,13 @@
       /// \brief Forward or reverse dumping
       ///
-      /// If this tag is defined to be \c True, then reverse dumping
-      /// is provided in the path dumper. In this case, \c RevArcIt
-      /// iterator should be implemented instead of \c ArcIt iterator.
+      /// If the RevPathTag is defined and true then reverse dumping
+      /// is provided in the path dumper. In this case instead of the
+      /// ArcIt the RevArcIt iterator should be implemented in the
+      /// dumper.
       typedef False RevPathTag;
 
-      /// \brief LEMON style iterator for enumerating the arcs of a path.
+      /// \brief LEMON style iterator for path arcs
       ///
-      /// LEMON style iterator class for enumerating the arcs of a path.
+      /// This class is used to iterate on the arcs of the paths.
       class ArcIt {
       public:
@@ -247,8 +245,8 @@
         /// Invalid constructor
         ArcIt(Invalid) {}
-        /// Sets the iterator to the first arc of the given path
+        /// Constructor for first arc
         ArcIt(const PathDumper&) {}
 
-        /// Conversion to \c Arc
+        /// Conversion to Arc
         operator Arc() const { return INVALID; }
 
@@ -265,9 +263,8 @@
       };
 
-      /// \brief LEMON style iterator for enumerating the arcs of a path
-      /// in reverse direction.
+      /// \brief LEMON style iterator for path arcs
       ///
-      /// LEMON style iterator class for enumerating the arcs of a path
-      /// in reverse direction.
+      /// This class is used to iterate on the arcs of the paths in
+      /// reverse direction.
       class RevArcIt {
       public:
@@ -276,8 +273,8 @@
         /// Invalid constructor
         RevArcIt(Invalid) {}
-        /// Sets the iterator to the last arc of the given path
+        /// Constructor for first arc
         RevArcIt(const PathDumper &) {}
 
-        /// Conversion to \c Arc
+        /// Conversion to Arc
         operator Arc() const { return INVALID; }
 
Index: lemon/config.h.cmake
===================================================================
--- lemon/config.h.cmake	(revision 725)
+++ lemon/config.h.cmake	(revision 725)
@@ -0,0 +1,8 @@
+#define LEMON_VERSION "@PROJECT_VERSION@"
+#cmakedefine LEMON_HAVE_LONG_LONG 1
+#cmakedefine LEMON_HAVE_LP 1
+#cmakedefine LEMON_HAVE_MIP 1
+#cmakedefine LEMON_HAVE_GLPK 1
+#cmakedefine LEMON_HAVE_CPLEX 1
+#cmakedefine LEMON_HAVE_CLP 1
+#cmakedefine LEMON_HAVE_CBC 1
Index: lemon/config.h.in
===================================================================
--- lemon/config.h.in	(revision 1232)
+++ lemon/config.h.in	(revision 725)
@@ -1,12 +1,26 @@
-#define LEMON_VERSION "@PROJECT_VERSION@"
-#cmakedefine LEMON_HAVE_LONG_LONG 1
-#cmakedefine LEMON_HAVE_LP 1
-#cmakedefine LEMON_HAVE_MIP 1
-#cmakedefine LEMON_HAVE_GLPK 1
-#cmakedefine LEMON_HAVE_CPLEX 1
-#cmakedefine LEMON_HAVE_CLP 1
-#cmakedefine LEMON_HAVE_CBC 1
-#cmakedefine LEMON_DEFAULT_LP @LEMON_DEFAULT_LP@
-#cmakedefine LEMON_DEFAULT_MIP @LEMON_DEFAULT_MIP@
-#cmakedefine LEMON_USE_PTHREAD 1
-#cmakedefine LEMON_USE_WIN32_THREADS 1
+/* The version string */
+#undef LEMON_VERSION
+
+/* Define to 1 if you have long long */
+#undef LEMON_HAVE_LONG_LONG
+
+/* Define to 1 if you have any LP solver. */
+#undef LEMON_HAVE_LP
+
+/* Define to 1 if you have any MIP solver. */
+#undef LEMON_HAVE_MIP
+
+/* Define to 1 if you have CPLEX. */
+#undef LEMON_HAVE_CPLEX
+
+/* Define to 1 if you have GLPK. */
+#undef LEMON_HAVE_GLPK
+
+/* Define to 1 if you have SOPLEX */
+#undef LEMON_HAVE_SOPLEX
+
+/* Define to 1 if you have CLP */
+#undef LEMON_HAVE_CLP
+
+/* Define to 1 if you have CBC */
+#undef LEMON_HAVE_CBC
Index: lemon/connectivity.h
===================================================================
--- lemon/connectivity.h	(revision 956)
+++ lemon/connectivity.h	(revision 695)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -259,5 +259,5 @@
   /// \return \c true if the digraph is strongly connected.
   /// \note By definition, the empty digraph is strongly connected.
-  ///
+  /// 
   /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   /// \see connected()
@@ -311,5 +311,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of strongly connected components of a
+  /// \brief Count the number of strongly connected components of a 
   /// directed graph
   ///
@@ -745,5 +745,5 @@
   /// \brief Check whether an undirected graph is bi-node-connected.
   ///
-  /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is 
   /// bi-node-connected, i.e. any two edges are on same circle.
   ///
@@ -759,5 +759,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of bi-node-connected components of an
+  /// \brief Count the number of bi-node-connected components of an 
   /// undirected graph.
   ///
@@ -813,5 +813,5 @@
   /// \retval compMap A writable edge map. The values will be set from 0
   /// to the number of the bi-node-connected components minus one. Each
-  /// value of the map will be set exactly once, and the values of a
+  /// value of the map will be set exactly once, and the values of a 
   /// certain component will be set continuously.
   /// \return The number of bi-node-connected components.
@@ -859,5 +859,5 @@
   ///
   /// \param graph The undirected graph.
-  /// \retval cutMap A writable node map. The values will be set to
+  /// \retval cutMap A writable node map. The values will be set to 
   /// \c true for the nodes that separate two or more components
   /// (exactly once for each cut node), and will not be changed for
@@ -1086,5 +1086,5 @@
   /// \brief Check whether an undirected graph is bi-edge-connected.
   ///
-  /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is 
   /// bi-edge-connected, i.e. any two nodes are connected with at least
   /// two edge-disjoint paths.
@@ -1193,5 +1193,5 @@
   ///
   /// This function finds the bi-edge-connected cut edges in the given
-  /// undirected graph.
+  /// undirected graph. 
   ///
   /// The bi-edge-connected components are the classes of an equivalence
@@ -1350,5 +1350,5 @@
   /// \param digraph The digraph.
   /// \retval order A readable and writable node map. The values will be
-  /// set from 0 to the number of the nodes in the digraph minus one.
+  /// set from 0 to the number of the nodes in the digraph minus one. 
   /// Each value of the map will be set exactly once, and the values will
   /// be set descending order.
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 1239)
+++ lemon/core.h	(revision 1246)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,4 +39,10 @@
 
 #ifdef __GNUC__
+#define GCC_VERSION (__GNUC__ * 10000                   \
+                     + __GNUC_MINOR__ * 100             \
+                     + __GNUC_PATCHLEVEL__)
+#endif
+
+#if GCC_VERSION >= 40800
 // Needed by the [DI]GRAPH_TYPEDEFS marcos for gcc 4.8
 #pragma GCC diagnostic ignored "-Wunused-local-typedefs"
@@ -154,47 +160,4 @@
   typedef typename Graph::template EdgeMap<double> DoubleEdgeMap
 
-  ///Create convenience typedefs for the bipartite graph types and iterators
-
-  ///This \c \#define creates the same convenient type definitions as
-  ///defined by \ref GRAPH_TYPEDEFS(BpGraph) and ten more, namely it
-  ///creates \c RedNode, \c RedNodeIt, \c BoolRedNodeMap,
-  ///\c IntRedNodeMap, \c DoubleRedNodeMap, \c BlueNode, \c BlueNodeIt,
-  ///\c BoolBlueNodeMap, \c IntBlueNodeMap, \c DoubleBlueNodeMap.
-  ///
-  ///\note If the graph type is a dependent type, ie. the graph type depend
-  ///on a template parameter, then use \c TEMPLATE_BPGRAPH_TYPEDEFS()
-  ///macro.
-#define BPGRAPH_TYPEDEFS(BpGraph)                                       \
-  GRAPH_TYPEDEFS(BpGraph);                                              \
-  typedef BpGraph::RedNode RedNode;                                     \
-  typedef BpGraph::RedNodeIt RedNodeIt;                                 \
-  typedef BpGraph::RedNodeMap<bool> BoolRedNodeMap;                     \
-  typedef BpGraph::RedNodeMap<int> IntRedNodeMap;                       \
-  typedef BpGraph::RedNodeMap<double> DoubleRedNodeMap;                 \
-  typedef BpGraph::BlueNode BlueNode;                                   \
-  typedef BpGraph::BlueNodeIt BlueNodeIt;                               \
-  typedef BpGraph::BlueNodeMap<bool> BoolBlueNodeMap;                   \
-  typedef BpGraph::BlueNodeMap<int> IntBlueNodeMap;                     \
-  typedef BpGraph::BlueNodeMap<double> DoubleBlueNodeMap
-
-  ///Create convenience typedefs for the bipartite graph types and iterators
-
-  ///\see BPGRAPH_TYPEDEFS
-  ///
-  ///\note Use this macro, if the graph type is a dependent type,
-  ///ie. the graph type depend on a template parameter.
-#define TEMPLATE_BPGRAPH_TYPEDEFS(BpGraph)                                  \
-  TEMPLATE_GRAPH_TYPEDEFS(BpGraph);                                         \
-  typedef typename BpGraph::RedNode RedNode;                                \
-  typedef typename BpGraph::RedNodeIt RedNodeIt;                            \
-  typedef typename BpGraph::template RedNodeMap<bool> BoolRedNodeMap;       \
-  typedef typename BpGraph::template RedNodeMap<int> IntRedNodeMap;         \
-  typedef typename BpGraph::template RedNodeMap<double> DoubleRedNodeMap;   \
-  typedef typename BpGraph::BlueNode BlueNode;                              \
-  typedef typename BpGraph::BlueNodeIt BlueNodeIt;                          \
-  typedef typename BpGraph::template BlueNodeMap<bool> BoolBlueNodeMap;     \
-  typedef typename BpGraph::template BlueNodeMap<int> IntBlueNodeMap;       \
-  typedef typename BpGraph::template BlueNodeMap<double> DoubleBlueNodeMap
-
   /// \brief Function to count the items in a graph.
   ///
@@ -248,72 +211,4 @@
   }
 
-  namespace _graph_utils_bits {
-    
-    template <typename Graph, typename Enable = void>
-    struct CountRedNodesSelector {
-      static int count(const Graph &g) {
-        return countItems<Graph, typename Graph::RedNode>(g);
-      }
-    };
-
-    template <typename Graph>
-    struct CountRedNodesSelector<
-      Graph, typename 
-      enable_if<typename Graph::NodeNumTag, void>::type> 
-    {
-      static int count(const Graph &g) {
-        return g.redNum();
-      }
-    };    
-  }
-
-  /// \brief Function to count the red nodes in the graph.
-  ///
-  /// This function counts the red nodes in the graph.
-  /// The complexity of the function is O(n) but for some
-  /// graph structures it is specialized to run in O(1).
-  ///
-  /// If the graph contains a \e redNum() member function and a 
-  /// \e NodeNumTag tag then this function calls directly the member
-  /// function to query the cardinality of the node set.
-  template <typename Graph>
-  inline int countRedNodes(const Graph& g) {
-    return _graph_utils_bits::CountRedNodesSelector<Graph>::count(g);
-  }
-
-  namespace _graph_utils_bits {
-    
-    template <typename Graph, typename Enable = void>
-    struct CountBlueNodesSelector {
-      static int count(const Graph &g) {
-        return countItems<Graph, typename Graph::BlueNode>(g);
-      }
-    };
-
-    template <typename Graph>
-    struct CountBlueNodesSelector<
-      Graph, typename 
-      enable_if<typename Graph::NodeNumTag, void>::type> 
-    {
-      static int count(const Graph &g) {
-        return g.blueNum();
-      }
-    };    
-  }
-
-  /// \brief Function to count the blue nodes in the graph.
-  ///
-  /// This function counts the blue nodes in the graph.
-  /// The complexity of the function is O(n) but for some
-  /// graph structures it is specialized to run in O(1).
-  ///
-  /// If the graph contains a \e blueNum() member function and a 
-  /// \e NodeNumTag tag then this function calls directly the member
-  /// function to query the cardinality of the node set.
-  template <typename Graph>
-  inline int countBlueNodes(const Graph& g) {
-    return _graph_utils_bits::CountBlueNodesSelector<Graph>::count(g);
-  }
-
   // Arc counting:
 
@@ -557,67 +452,10 @@
       template <typename From, typename NodeRefMap, typename EdgeRefMap>
       static void copy(const From& from, Graph &to,
-                       NodeRefMap& nodeRefMap,
-                       EdgeRefMap& edgeRefMap) {
+                       NodeRefMap& nodeRefMap, EdgeRefMap& edgeRefMap) {
         to.build(from, nodeRefMap, edgeRefMap);
       }
     };
 
-    template <typename BpGraph, typename Enable = void>
-    struct BpGraphCopySelector {
-      template <typename From, typename RedNodeRefMap,
-                typename BlueNodeRefMap, typename EdgeRefMap>
-      static void copy(const From& from, BpGraph &to,
-                       RedNodeRefMap& redNodeRefMap,
-                       BlueNodeRefMap& blueNodeRefMap,
-                       EdgeRefMap& edgeRefMap) {
-        to.clear();
-        for (typename From::RedNodeIt it(from); it != INVALID; ++it) {
-          redNodeRefMap[it] = to.addRedNode();
-        }
-        for (typename From::BlueNodeIt it(from); it != INVALID; ++it) {
-          blueNodeRefMap[it] = to.addBlueNode();
-        }
-        for (typename From::EdgeIt it(from); it != INVALID; ++it) {
-          edgeRefMap[it] = to.addEdge(redNodeRefMap[from.redNode(it)],
-                                      blueNodeRefMap[from.blueNode(it)]);
-        }
-      }
-    };
-
-    template <typename BpGraph>
-    struct BpGraphCopySelector<
-      BpGraph,
-      typename enable_if<typename BpGraph::BuildTag, void>::type>
-    {
-      template <typename From, typename RedNodeRefMap,
-                typename BlueNodeRefMap, typename EdgeRefMap>
-      static void copy(const From& from, BpGraph &to,
-                       RedNodeRefMap& redNodeRefMap,
-                       BlueNodeRefMap& blueNodeRefMap,
-                       EdgeRefMap& edgeRefMap) {
-        to.build(from, redNodeRefMap, blueNodeRefMap, edgeRefMap);
-      }
-    };
-
   }
-
-  /// \brief Check whether a graph is undirected.
-  ///
-  /// This function returns \c true if the given graph is undirected.
-#ifdef DOXYGEN
-  template <typename GR>
-  bool undirected(const GR& g) { return false; }
-#else
-  template <typename GR>
-  typename enable_if<UndirectedTagIndicator<GR>, bool>::type
-  undirected(const GR&) {
-    return true;
-  }
-  template <typename GR>
-  typename disable_if<UndirectedTagIndicator<GR>, bool>::type
-  undirected(const GR&) {
-    return false;
-  }
-#endif
 
   /// \brief Class to copy a digraph.
@@ -1144,452 +982,4 @@
   graphCopy(const From& from, To& to) {
     return GraphCopy<From, To>(from, to);
-  }
-
-  /// \brief Class to copy a bipartite graph.
-  ///
-  /// Class to copy a bipartite graph to another graph (duplicate a
-  /// graph). The simplest way of using it is through the
-  /// \c bpGraphCopy() function.
-  ///
-  /// This class not only make a copy of a bipartite graph, but it can
-  /// create references and cross references between the nodes, edges
-  /// and arcs of the two graphs, and it can copy maps for using with
-  /// the newly created graph.
-  ///
-  /// To make a copy from a graph, first an instance of BpGraphCopy
-  /// should be created, then the data belongs to the graph should
-  /// assigned to copy. In the end, the \c run() member should be
-  /// called.
-  ///
-  /// The next code copies a graph with several data:
-  ///\code
-  ///  BpGraphCopy<OrigBpGraph, NewBpGraph> cg(orig_graph, new_graph);
-  ///  // Create references for the nodes
-  ///  OrigBpGraph::NodeMap<NewBpGraph::Node> nr(orig_graph);
-  ///  cg.nodeRef(nr);
-  ///  // Create cross references (inverse) for the edges
-  ///  NewBpGraph::EdgeMap<OrigBpGraph::Edge> ecr(new_graph);
-  ///  cg.edgeCrossRef(ecr);
-  ///  // Copy a red node map
-  ///  OrigBpGraph::RedNodeMap<double> ormap(orig_graph);
-  ///  NewBpGraph::RedNodeMap<double> nrmap(new_graph);
-  ///  cg.redNodeMap(ormap, nrmap);
-  ///  // Copy a node
-  ///  OrigBpGraph::Node on;
-  ///  NewBpGraph::Node nn;
-  ///  cg.node(on, nn);
-  ///  // Execute copying
-  ///  cg.run();
-  ///\endcode
-  template <typename From, typename To>
-  class BpGraphCopy {
-  private:
-
-    typedef typename From::Node Node;
-    typedef typename From::RedNode RedNode;
-    typedef typename From::BlueNode BlueNode;
-    typedef typename From::NodeIt NodeIt;
-    typedef typename From::Arc Arc;
-    typedef typename From::ArcIt ArcIt;
-    typedef typename From::Edge Edge;
-    typedef typename From::EdgeIt EdgeIt;
-
-    typedef typename To::Node TNode;
-    typedef typename To::RedNode TRedNode;
-    typedef typename To::BlueNode TBlueNode;
-    typedef typename To::Arc TArc;
-    typedef typename To::Edge TEdge;
-
-    typedef typename From::template RedNodeMap<TRedNode> RedNodeRefMap;
-    typedef typename From::template BlueNodeMap<TBlueNode> BlueNodeRefMap;
-    typedef typename From::template EdgeMap<TEdge> EdgeRefMap;
-
-    struct NodeRefMap {
-      NodeRefMap(const From& from, const RedNodeRefMap& red_node_ref,
-                 const BlueNodeRefMap& blue_node_ref)
-        : _from(from), _red_node_ref(red_node_ref),
-          _blue_node_ref(blue_node_ref) {}
-
-      typedef typename From::Node Key;
-      typedef typename To::Node Value;
-
-      Value operator[](const Key& key) const {
-        if (_from.red(key)) {
-          return _red_node_ref[_from.asRedNodeUnsafe(key)];
-        } else {
-          return _blue_node_ref[_from.asBlueNodeUnsafe(key)];
-        }
-      }
-
-      const From& _from;
-      const RedNodeRefMap& _red_node_ref;
-      const BlueNodeRefMap& _blue_node_ref;
-    };
-
-    struct ArcRefMap {
-      ArcRefMap(const From& from, const To& to, const EdgeRefMap& edge_ref)
-        : _from(from), _to(to), _edge_ref(edge_ref) {}
-
-      typedef typename From::Arc Key;
-      typedef typename To::Arc Value;
-
-      Value operator[](const Key& key) const {
-        return _to.direct(_edge_ref[key], _from.direction(key));
-      }
-
-      const From& _from;
-      const To& _to;
-      const EdgeRefMap& _edge_ref;
-    };
-
-  public:
-
-    /// \brief Constructor of BpGraphCopy.
-    ///
-    /// Constructor of BpGraphCopy for copying the content of the
-    /// \c from graph into the \c to graph.
-    BpGraphCopy(const From& from, To& to)
-      : _from(from), _to(to) {}
-
-    /// \brief Destructor of BpGraphCopy
-    ///
-    /// Destructor of BpGraphCopy.
-    ~BpGraphCopy() {
-      for (int i = 0; i < int(_node_maps.size()); ++i) {
-        delete _node_maps[i];
-      }
-      for (int i = 0; i < int(_red_maps.size()); ++i) {
-        delete _red_maps[i];
-      }
-      for (int i = 0; i < int(_blue_maps.size()); ++i) {
-        delete _blue_maps[i];
-      }
-      for (int i = 0; i < int(_arc_maps.size()); ++i) {
-        delete _arc_maps[i];
-      }
-      for (int i = 0; i < int(_edge_maps.size()); ++i) {
-        delete _edge_maps[i];
-      }
-    }
-
-    /// \brief Copy the node references into the given map.
-    ///
-    /// This function copies the node references into the given map.
-    /// The parameter should be a map, whose key type is the Node type of
-    /// the source graph, while the value type is the Node type of the
-    /// destination graph.
-    template <typename NodeRef>
-    BpGraphCopy& nodeRef(NodeRef& map) {
-      _node_maps.push_back(new _core_bits::RefCopy<From, Node,
-                           NodeRefMap, NodeRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the node cross references into the given map.
-    ///
-    /// This function copies the node cross references (reverse references)
-    /// into the given map. The parameter should be a map, whose key type
-    /// is the Node type of the destination graph, while the value type is
-    /// the Node type of the source graph.
-    template <typename NodeCrossRef>
-    BpGraphCopy& nodeCrossRef(NodeCrossRef& map) {
-      _node_maps.push_back(new _core_bits::CrossRefCopy<From, Node,
-                           NodeRefMap, NodeCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given node map.
-    ///
-    /// This function makes a copy of the given node map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Node type of the
-    /// destination graph, and the key type of the original map \c map
-    /// should be the Node type of the source graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& nodeMap(const FromMap& map, ToMap& tmap) {
-      _node_maps.push_back(new _core_bits::MapCopy<From, Node,
-                           NodeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given node.
-    ///
-    /// This function makes a copy of the given node.
-    BpGraphCopy& node(const Node& node, TNode& tnode) {
-      _node_maps.push_back(new _core_bits::ItemCopy<From, Node,
-                           NodeRefMap, TNode>(node, tnode));
-      return *this;
-    }
-
-    /// \brief Copy the red node references into the given map.
-    ///
-    /// This function copies the red node references into the given
-    /// map.  The parameter should be a map, whose key type is the
-    /// Node type of the source graph with the red item set, while the
-    /// value type is the Node type of the destination graph.
-    template <typename RedRef>
-    BpGraphCopy& redRef(RedRef& map) {
-      _red_maps.push_back(new _core_bits::RefCopy<From, RedNode,
-                          RedNodeRefMap, RedRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the red node cross references into the given map.
-    ///
-    /// This function copies the red node cross references (reverse
-    /// references) into the given map. The parameter should be a map,
-    /// whose key type is the Node type of the destination graph with
-    /// the red item set, while the value type is the Node type of the
-    /// source graph.
-    template <typename RedCrossRef>
-    BpGraphCopy& redCrossRef(RedCrossRef& map) {
-      _red_maps.push_back(new _core_bits::CrossRefCopy<From, RedNode,
-                          RedNodeRefMap, RedCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given red node map.
-    ///
-    /// This function makes a copy of the given red node map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Node type of
-    /// the destination graph with the red items, and the key type of
-    /// the original map \c map should be the Node type of the source
-    /// graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& redNodeMap(const FromMap& map, ToMap& tmap) {
-      _red_maps.push_back(new _core_bits::MapCopy<From, RedNode,
-                          RedNodeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given red node.
-    ///
-    /// This function makes a copy of the given red node.
-    BpGraphCopy& redNode(const RedNode& node, TRedNode& tnode) {
-      _red_maps.push_back(new _core_bits::ItemCopy<From, RedNode,
-                          RedNodeRefMap, TRedNode>(node, tnode));
-      return *this;
-    }
-
-    /// \brief Copy the blue node references into the given map.
-    ///
-    /// This function copies the blue node references into the given
-    /// map.  The parameter should be a map, whose key type is the
-    /// Node type of the source graph with the blue item set, while the
-    /// value type is the Node type of the destination graph.
-    template <typename BlueRef>
-    BpGraphCopy& blueRef(BlueRef& map) {
-      _blue_maps.push_back(new _core_bits::RefCopy<From, BlueNode,
-                           BlueNodeRefMap, BlueRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the blue node cross references into the given map.
-    ///
-    /// This function copies the blue node cross references (reverse
-    /// references) into the given map. The parameter should be a map,
-    /// whose key type is the Node type of the destination graph with
-    /// the blue item set, while the value type is the Node type of the
-    /// source graph.
-    template <typename BlueCrossRef>
-    BpGraphCopy& blueCrossRef(BlueCrossRef& map) {
-      _blue_maps.push_back(new _core_bits::CrossRefCopy<From, BlueNode,
-                           BlueNodeRefMap, BlueCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given blue node map.
-    ///
-    /// This function makes a copy of the given blue node map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Node type of
-    /// the destination graph with the blue items, and the key type of
-    /// the original map \c map should be the Node type of the source
-    /// graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& blueNodeMap(const FromMap& map, ToMap& tmap) {
-      _blue_maps.push_back(new _core_bits::MapCopy<From, BlueNode,
-                           BlueNodeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given blue node.
-    ///
-    /// This function makes a copy of the given blue node.
-    BpGraphCopy& blueNode(const BlueNode& node, TBlueNode& tnode) {
-      _blue_maps.push_back(new _core_bits::ItemCopy<From, BlueNode,
-                           BlueNodeRefMap, TBlueNode>(node, tnode));
-      return *this;
-    }
-
-    /// \brief Copy the arc references into the given map.
-    ///
-    /// This function copies the arc references into the given map.
-    /// The parameter should be a map, whose key type is the Arc type of
-    /// the source graph, while the value type is the Arc type of the
-    /// destination graph.
-    template <typename ArcRef>
-    BpGraphCopy& arcRef(ArcRef& map) {
-      _arc_maps.push_back(new _core_bits::RefCopy<From, Arc,
-                          ArcRefMap, ArcRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the arc cross references into the given map.
-    ///
-    /// This function copies the arc cross references (reverse references)
-    /// into the given map. The parameter should be a map, whose key type
-    /// is the Arc type of the destination graph, while the value type is
-    /// the Arc type of the source graph.
-    template <typename ArcCrossRef>
-    BpGraphCopy& arcCrossRef(ArcCrossRef& map) {
-      _arc_maps.push_back(new _core_bits::CrossRefCopy<From, Arc,
-                          ArcRefMap, ArcCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given arc map.
-    ///
-    /// This function makes a copy of the given arc map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Arc type of the
-    /// destination graph, and the key type of the original map \c map
-    /// should be the Arc type of the source graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& arcMap(const FromMap& map, ToMap& tmap) {
-      _arc_maps.push_back(new _core_bits::MapCopy<From, Arc,
-                          ArcRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given arc.
-    ///
-    /// This function makes a copy of the given arc.
-    BpGraphCopy& arc(const Arc& arc, TArc& tarc) {
-      _arc_maps.push_back(new _core_bits::ItemCopy<From, Arc,
-                          ArcRefMap, TArc>(arc, tarc));
-      return *this;
-    }
-
-    /// \brief Copy the edge references into the given map.
-    ///
-    /// This function copies the edge references into the given map.
-    /// The parameter should be a map, whose key type is the Edge type of
-    /// the source graph, while the value type is the Edge type of the
-    /// destination graph.
-    template <typename EdgeRef>
-    BpGraphCopy& edgeRef(EdgeRef& map) {
-      _edge_maps.push_back(new _core_bits::RefCopy<From, Edge,
-                           EdgeRefMap, EdgeRef>(map));
-      return *this;
-    }
-
-    /// \brief Copy the edge cross references into the given map.
-    ///
-    /// This function copies the edge cross references (reverse references)
-    /// into the given map. The parameter should be a map, whose key type
-    /// is the Edge type of the destination graph, while the value type is
-    /// the Edge type of the source graph.
-    template <typename EdgeCrossRef>
-    BpGraphCopy& edgeCrossRef(EdgeCrossRef& map) {
-      _edge_maps.push_back(new _core_bits::CrossRefCopy<From,
-                           Edge, EdgeRefMap, EdgeCrossRef>(map));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given edge map.
-    ///
-    /// This function makes a copy of the given edge map for the newly
-    /// created graph.
-    /// The key type of the new map \c tmap should be the Edge type of the
-    /// destination graph, and the key type of the original map \c map
-    /// should be the Edge type of the source graph.
-    template <typename FromMap, typename ToMap>
-    BpGraphCopy& edgeMap(const FromMap& map, ToMap& tmap) {
-      _edge_maps.push_back(new _core_bits::MapCopy<From, Edge,
-                           EdgeRefMap, FromMap, ToMap>(map, tmap));
-      return *this;
-    }
-
-    /// \brief Make a copy of the given edge.
-    ///
-    /// This function makes a copy of the given edge.
-    BpGraphCopy& edge(const Edge& edge, TEdge& tedge) {
-      _edge_maps.push_back(new _core_bits::ItemCopy<From, Edge,
-                           EdgeRefMap, TEdge>(edge, tedge));
-      return *this;
-    }
-
-    /// \brief Execute copying.
-    ///
-    /// This function executes the copying of the graph along with the
-    /// copying of the assigned data.
-    void run() {
-      RedNodeRefMap redNodeRefMap(_from);
-      BlueNodeRefMap blueNodeRefMap(_from);
-      NodeRefMap nodeRefMap(_from, redNodeRefMap, blueNodeRefMap);
-      EdgeRefMap edgeRefMap(_from);
-      ArcRefMap arcRefMap(_from, _to, edgeRefMap);
-      _core_bits::BpGraphCopySelector<To>::
-        copy(_from, _to, redNodeRefMap, blueNodeRefMap, edgeRefMap);
-      for (int i = 0; i < int(_node_maps.size()); ++i) {
-        _node_maps[i]->copy(_from, nodeRefMap);
-      }
-      for (int i = 0; i < int(_red_maps.size()); ++i) {
-        _red_maps[i]->copy(_from, redNodeRefMap);
-      }
-      for (int i = 0; i < int(_blue_maps.size()); ++i) {
-        _blue_maps[i]->copy(_from, blueNodeRefMap);
-      }
-      for (int i = 0; i < int(_edge_maps.size()); ++i) {
-        _edge_maps[i]->copy(_from, edgeRefMap);
-      }
-      for (int i = 0; i < int(_arc_maps.size()); ++i) {
-        _arc_maps[i]->copy(_from, arcRefMap);
-      }
-    }
-
-  private:
-
-    const From& _from;
-    To& _to;
-
-    std::vector<_core_bits::MapCopyBase<From, Node, NodeRefMap>* >
-      _node_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, RedNode, RedNodeRefMap>* >
-      _red_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, BlueNode, BlueNodeRefMap>* >
-      _blue_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, Arc, ArcRefMap>* >
-      _arc_maps;
-
-    std::vector<_core_bits::MapCopyBase<From, Edge, EdgeRefMap>* >
-      _edge_maps;
-
-  };
-
-  /// \brief Copy a graph to another graph.
-  ///
-  /// This function copies a graph to another graph.
-  /// The complete usage of it is detailed in the BpGraphCopy class,
-  /// but a short example shows a basic work:
-  ///\code
-  /// graphCopy(src, trg).nodeRef(nr).edgeCrossRef(ecr).run();
-  ///\endcode
-  ///
-  /// After the copy the \c nr map will contain the mapping from the
-  /// nodes of the \c from graph to the nodes of the \c to graph and
-  /// \c ecr will contain the mapping from the edges of the \c to graph
-  /// to the edges of the \c from graph.
-  ///
-  /// \see BpGraphCopy
-  template <typename From, typename To>
-  BpGraphCopy<From, To>
-  bpGraphCopy(const From& from, To& to) {
-    return BpGraphCopy<From, To>(from, to);
   }
 
@@ -1860,9 +1250,8 @@
     /// The Digraph type
     typedef GR Digraph;
-    
+
   protected:
 
-    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type
-    {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
       typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 
@@ -1903,5 +1292,5 @@
     };
 
-  protected:
+  protected: 
 
     const Digraph &_g;
Index: lemon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 1254)
+++ 	(revision )
@@ -1,1606 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_COST_SCALING_H
-#define LEMON_COST_SCALING_H
-
-/// \ingroup min_cost_flow_algs
-/// \file
-/// \brief Cost scaling algorithm for finding a minimum cost flow.
-
-#include <vector>
-#include <deque>
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/maps.h>
-#include <lemon/math.h>
-#include <lemon/static_graph.h>
-#include <lemon/circulation.h>
-#include <lemon/bellman_ford.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of CostScaling algorithm.
-  ///
-  /// Default traits class of CostScaling algorithm.
-  /// \tparam GR Digraph type.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values. By default it is \c int.
-  /// \tparam C The number type used for costs and potentials.
-  /// By default it is the same as \c V.
-#ifdef DOXYGEN
-  template <typename GR, typename V = int, typename C = V>
-#else
-  template < typename GR, typename V = int, typename C = V,
-             bool integer = std::numeric_limits<C>::is_integer >
-#endif
-  struct CostScalingDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef V Value;
-    /// The type of the arc costs
-    typedef C Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename V, typename C>
-  struct CostScalingDefaultTraits<GR, V, C, true>
-  {
-    typedef GR Digraph;
-    typedef V Value;
-    typedef C Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-  };
-
-
-  /// \addtogroup min_cost_flow_algs
-  /// @{
-
-  /// \brief Implementation of the Cost Scaling algorithm for
-  /// finding a \ref min_cost_flow "minimum cost flow".
-  ///
-  /// \ref CostScaling implements a cost scaling algorithm that performs
-  /// push/augment and relabel operations for finding a \ref min_cost_flow
-  /// "minimum cost flow" \cite amo93networkflows, \cite goldberg90approximation,
-  /// \cite goldberg97efficient, \cite bunnagel98efficient.
-  /// It is a highly efficient primal-dual solution method, which
-  /// can be viewed as the generalization of the \ref Preflow
-  /// "preflow push-relabel" algorithm for the maximum flow problem.
-  /// It is a polynomial algorithm, its running time complexity is
-  /// \f$O(n^2m\log(nK))\f$, where <i>K</i> denotes the maximum arc cost.
-  ///
-  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
-  /// implementations available in LEMON for solving this problem.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
-  ///
-  /// Most of the parameters of the problem (except for the digraph)
-  /// can be given using separate functions, and the algorithm can be
-  /// executed using the \ref run() function. If some parameters are not
-  /// specified, then default values will be used.
-  ///
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref CostScalingDefaultTraits
-  /// "CostScalingDefaultTraits<GR, V, C>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-  ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
-  /// be integer.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
-  ///
-  /// \note %CostScaling provides three different internal methods,
-  /// from which the most efficient one is used by default.
-  /// For more information, see \ref Method.
-#ifdef DOXYGEN
-  template <typename GR, typename V, typename C, typename TR>
-#else
-  template < typename GR, typename V = int, typename C = V,
-             typename TR = CostScalingDefaultTraits<GR, V, C> >
-#endif
-  class CostScaling
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef typename TR::Value Value;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// \brief The \ref lemon::CostScalingDefaultTraits "traits class"
-    /// of the algorithm
-    typedef TR Traits;
-
-  public:
-
-    /// \brief Problem type constants for the \c run() function.
-    ///
-    /// Enum type containing the problem type constants that can be
-    /// returned by the \ref run() function of the algorithm.
-    enum ProblemType {
-      /// The problem has no feasible solution (flow).
-      INFEASIBLE,
-      /// The problem has optimal solution (i.e. it is feasible and
-      /// bounded), and the algorithm has found optimal flow and node
-      /// potentials (primal and dual solutions).
-      OPTIMAL,
-      /// The digraph contains an arc of negative cost and infinite
-      /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however, note that it could actually be bounded
-      /// over the feasible flows, but this algroithm cannot handle
-      /// these cases.
-      UNBOUNDED
-    };
-
-    /// \brief Constants for selecting the internal method.
-    ///
-    /// Enum type containing constants for selecting the internal method
-    /// for the \ref run() function.
-    ///
-    /// \ref CostScaling provides three internal methods that differ mainly
-    /// in their base operations, which are used in conjunction with the
-    /// relabel operation.
-    /// By default, the so called \ref PARTIAL_AUGMENT
-    /// "Partial Augment-Relabel" method is used, which turned out to be
-    /// the most efficient and the most robust on various test inputs.
-    /// However, the other methods can be selected using the \ref run()
-    /// function with the proper parameter.
-    enum Method {
-      /// Local push operations are used, i.e. flow is moved only on one
-      /// admissible arc at once.
-      PUSH,
-      /// Augment operations are used, i.e. flow is moved on admissible
-      /// paths from a node with excess to a node with deficit.
-      AUGMENT,
-      /// Partial augment operations are used, i.e. flow is moved on
-      /// admissible paths started from a node with excess, but the
-      /// lengths of these paths are limited. This method can be viewed
-      /// as a combined version of the previous two operations.
-      PARTIAL_AUGMENT
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<Value> ValueVector;
-    typedef std::vector<Cost> CostVector;
-    typedef std::vector<LargeCost> LargeCostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-  private:
-
-    template <typename KT, typename VT>
-    class StaticVectorMap {
-    public:
-      typedef KT Key;
-      typedef VT Value;
-
-      StaticVectorMap(std::vector<Value>& v) : _v(v) {}
-
-      const Value& operator[](const Key& key) const {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      Value& operator[](const Key& key) {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      void set(const Key& key, const Value& val) {
-        _v[StaticDigraph::id(key)] = val;
-      }
-
-    private:
-      std::vector<Value>& _v;
-    };
-
-    typedef StaticVectorMap<StaticDigraph::Arc, LargeCost> LargeCostArcMap;
-
-  private:
-
-    // Data related to the underlying digraph
-    const GR &_graph;
-    int _node_num;
-    int _arc_num;
-    int _res_node_num;
-    int _res_arc_num;
-    int _root;
-
-    // Parameters of the problem
-    bool _have_lower;
-    Value _sum_supply;
-    int _sup_node_num;
-
-    // Data structures for storing the digraph
-    IntNodeMap _node_id;
-    IntArcMap _arc_idf;
-    IntArcMap _arc_idb;
-    IntVector _first_out;
-    BoolVector _forward;
-    IntVector _source;
-    IntVector _target;
-    IntVector _reverse;
-
-    // Node and arc data
-    ValueVector _lower;
-    ValueVector _upper;
-    CostVector _scost;
-    ValueVector _supply;
-
-    ValueVector _res_cap;
-    LargeCostVector _cost;
-    LargeCostVector _pi;
-    ValueVector _excess;
-    IntVector _next_out;
-    std::deque<int> _active_nodes;
-
-    // Data for scaling
-    LargeCost _epsilon;
-    int _alpha;
-
-    IntVector _buckets;
-    IntVector _bucket_next;
-    IntVector _bucket_prev;
-    IntVector _rank;
-    int _max_rank;
-
-  public:
-
-    /// \brief Constant for infinite upper bounds (capacities).
-    ///
-    /// Constant for infinite upper bounds (capacities).
-    /// It is \c std::numeric_limits<Value>::infinity() if available,
-    /// \c std::numeric_limits<Value>::max() otherwise.
-    const Value INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type, which is used for internal computations in the algorithm.
-    /// \c Cost must be convertible to \c LargeCost.
-    template <typename T>
-    struct SetLargeCost
-      : public CostScaling<GR, V, C, SetLargeCostTraits<T> > {
-      typedef  CostScaling<GR, V, C, SetLargeCostTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    CostScaling() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    CostScaling(const GR& graph) :
-      _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),
-      INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() :
-          std::numeric_limits<Value>::max())
-    {
-      // Check the number types
-      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
-        "The flow type of CostScaling must be signed");
-      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
-        "The cost type of CostScaling must be signed");
-
-      // Reset data structures
-      reset();
-    }
-
-    /// \name Parameters
-    /// The parameters of the algorithm can be specified using these
-    /// functions.
-
-    /// @{
-
-    /// \brief Set the lower bounds on the arcs.
-    ///
-    /// This function sets the lower bounds on the arcs.
-    /// If it is not used before calling \ref run(), the lower bounds
-    /// will be set to zero on all arcs.
-    ///
-    /// \param map An arc map storing the lower bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template <typename LowerMap>
-    CostScaling& lowerMap(const LowerMap& map) {
-      _have_lower = true;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _lower[_arc_idf[a]] = map[a];
-        _lower[_arc_idb[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the upper bounds (capacities) on the arcs.
-    ///
-    /// This function sets the upper bounds (capacities) on the arcs.
-    /// If it is not used before calling \ref run(), the upper bounds
-    /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
-    ///
-    /// \param map An arc map storing the upper bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename UpperMap>
-    CostScaling& upperMap(const UpperMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _upper[_arc_idf[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the costs of the arcs.
-    ///
-    /// This function sets the costs of the arcs.
-    /// If it is not used before calling \ref run(), the costs
-    /// will be set to \c 1 on all arcs.
-    ///
-    /// \param map An arc map storing the costs.
-    /// Its \c Value type must be convertible to the \c Cost type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename CostMap>
-    CostScaling& costMap(const CostMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _scost[_arc_idf[a]] =  map[a];
-        _scost[_arc_idb[a]] = -map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the supply values of the nodes.
-    ///
-    /// This function sets the supply values of the nodes.
-    /// If neither this function nor \ref stSupply() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// \param map A node map storing the supply values.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename SupplyMap>
-    CostScaling& supplyMap(const SupplyMap& map) {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _supply[_node_id[n]] = map[n];
-      }
-      return *this;
-    }
-
-    /// \brief Set single source and target nodes and a supply value.
-    ///
-    /// This function sets a single source node and a single target node
-    /// and the required flow value.
-    /// If neither this function nor \ref supplyMap() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
-    /// assigned to \c t and all other nodes have zero supply value.
-    ///
-    /// \param s The source node.
-    /// \param t The target node.
-    /// \param k The required amount of flow from node \c s to node \c t
-    /// (i.e. the supply of \c s and the demand of \c t).
-    ///
-    /// \return <tt>(*this)</tt>
-    CostScaling& stSupply(const Node& s, const Node& t, Value k) {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      _supply[_node_id[s]] =  k;
-      _supply[_node_id[t]] = -k;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Execution control
-    /// The algorithm can be executed using \ref run().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    /// For example,
-    /// \code
-    ///   CostScaling<ListDigraph> cs(graph);
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
-    ///
-    /// \param method The internal method that will be used in the
-    /// algorithm. For more information, see \ref Method.
-    /// \param factor The cost scaling factor. It must be at least two.
-    ///
-    /// \return \c INFEASIBLE if no feasible flow exists,
-    /// \n \c OPTIMAL if the problem has optimal solution
-    /// (i.e. it is feasible and bounded), and the algorithm has found
-    /// optimal flow and node potentials (primal and dual solutions),
-    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
-    /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however, note that it could actually be
-    /// bounded over the feasible flows, but this algroithm cannot handle
-    /// these cases.
-    ///
-    /// \see ProblemType, Method
-    /// \see resetParams(), reset()
-    ProblemType run(Method method = PARTIAL_AUGMENT, int factor = 16) {
-      LEMON_ASSERT(factor >= 2, "The scaling factor must be at least 2");
-      _alpha = factor;
-      ProblemType pt = init();
-      if (pt != OPTIMAL) return pt;
-      start(method);
-      return OPTIMAL;
-    }
-
-    /// \brief Reset all the parameters that have been given before.
-    ///
-    /// This function resets all the paramaters that have been given
-    /// before using functions \ref lowerMap(), \ref upperMap(),
-    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// For example,
-    /// \code
-    ///   CostScaling<ListDigraph> cs(graph);
-    ///
-    ///   // First run
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    ///
-    ///   // Run again with modified cost map (resetParams() is not called,
-    ///   // so only the cost map have to be set again)
-    ///   cost[e] += 100;
-    ///   cs.costMap(cost).run();
-    ///
-    ///   // Run again from scratch using resetParams()
-    ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cs.resetParams();
-    ///   cs.upperMap(capacity).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CostScaling& resetParams() {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      int limit = _first_out[_root];
-      for (int j = 0; j != limit; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _scost[j] = _forward[j] ? 1 : -1;
-      }
-      for (int j = limit; j != _res_arc_num; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _scost[j] = 0;
-        _scost[_reverse[j]] = 0;
-      }
-      _have_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. By default, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CostScaling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_node_num = _node_num + 1;
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-
-      _first_out.resize(_res_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _scost.resize(_res_arc_num);
-      _supply.resize(_res_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _pi.resize(_res_node_num);
-      _excess.resize(_res_node_num);
-      _next_out.resize(_res_node_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_res_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The \ref run() function must be called before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found flow.
-    ///
-    /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
-    ///
-    /// \note The return type of the function can be specified as a
-    /// template parameter. For example,
-    /// \code
-    ///   cs.totalCost<double>();
-    /// \endcode
-    /// It is useful if the total cost cannot be stored in the \c Cost
-    /// type of the algorithm, which is the default return type of the
-    /// function.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename Number>
-    Number totalCost() const {
-      Number c = 0;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int i = _arc_idb[a];
-        c += static_cast<Number>(_res_cap[i]) *
-             (-static_cast<Number>(_scost[i]));
-      }
-      return c;
-    }
-
-#ifndef DOXYGEN
-    Cost totalCost() const {
-      return totalCost<Cost>();
-    }
-#endif
-
-    /// \brief Return the flow on the given arc.
-    ///
-    /// This function returns the flow on the given arc.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value flow(const Arc& a) const {
-      return _res_cap[_arc_idb[a]];
-    }
-
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
-    ///
-    /// This function copies the flow value on each arc into the given
-    /// map. The \c Value type of the algorithm must be convertible to
-    /// the \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename FlowMap>
-    void flowMap(FlowMap &map) const {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        map.set(a, _res_cap[_arc_idb[a]]);
-      }
-    }
-
-    /// \brief Return the potential (dual value) of the given node.
-    ///
-    /// This function returns the potential (dual value) of the
-    /// given node.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Cost potential(const Node& n) const {
-      return static_cast<Cost>(_pi[_node_id[n]]);
-    }
-
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
-    ///
-    /// This function copies the potential (dual value) of each node
-    /// into the given map.
-    /// The \c Cost type of the algorithm must be convertible to the
-    /// \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename PotentialMap>
-    void potentialMap(PotentialMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map.set(n, static_cast<Cost>(_pi[_node_id[n]]));
-      }
-    }
-
-    /// @}
-
-  private:
-
-    // Initialize the algorithm
-    ProblemType init() {
-      if (_res_node_num <= 1) return INFEASIBLE;
-
-      // Check the sum of supply values
-      _sum_supply = 0;
-      for (int i = 0; i != _root; ++i) {
-        _sum_supply += _supply[i];
-      }
-      if (_sum_supply > 0) return INFEASIBLE;
-
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
-
-      // Initialize vectors
-      for (int i = 0; i != _res_node_num; ++i) {
-        _pi[i] = 0;
-        _excess[i] = _supply[i];
-      }
-
-      // Remove infinite upper bounds and check negative arcs
-      const Value MAX = std::numeric_limits<Value>::max();
-      int last_out;
-      if (_have_lower) {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j]) {
-              Value c = _scost[j] < 0 ? _upper[j] : _lower[j];
-              if (c >= MAX) return UNBOUNDED;
-              _excess[i] -= c;
-              _excess[_target[j]] += c;
-            }
-          }
-        }
-      } else {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j] && _scost[j] < 0) {
-              Value c = _upper[j];
-              if (c >= MAX) return UNBOUNDED;
-              _excess[i] -= c;
-              _excess[_target[j]] += c;
-            }
-          }
-        }
-      }
-      Value ex, max_cap = 0;
-      for (int i = 0; i != _res_node_num; ++i) {
-        ex = _excess[i];
-        _excess[i] = 0;
-        if (ex < 0) max_cap -= ex;
-      }
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_upper[j] >= MAX) _upper[j] = max_cap;
-      }
-
-      // Initialize the large cost vector and the epsilon parameter
-      _epsilon = 0;
-      LargeCost lc;
-      for (int i = 0; i != _root; ++i) {
-        last_out = _first_out[i+1];
-        for (int j = _first_out[i]; j != last_out; ++j) {
-          lc = static_cast<LargeCost>(_scost[j]) * _res_node_num * _alpha;
-          _cost[j] = lc;
-          if (lc > _epsilon) _epsilon = lc;
-        }
-      }
-      _epsilon /= _alpha;
-
-      // Initialize maps for Circulation and remove non-zero lower bounds
-      ConstMap<Arc, Value> low(0);
-      typedef typename Digraph::template ArcMap<Value> ValueArcMap;
-      typedef typename Digraph::template NodeMap<Value> ValueNodeMap;
-      ValueArcMap cap(_graph), flow(_graph);
-      ValueNodeMap sup(_graph);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sup[n] = _supply[_node_id[n]];
-      }
-      if (_have_lower) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          int j = _arc_idf[a];
-          Value c = _lower[j];
-          cap[a] = _upper[j] - c;
-          sup[_graph.source(a)] -= c;
-          sup[_graph.target(a)] += c;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          cap[a] = _upper[_arc_idf[a]];
-        }
-      }
-
-      _sup_node_num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (sup[n] > 0) ++_sup_node_num;
-      }
-
-      // Find a feasible flow using Circulation
-      Circulation<Digraph, ConstMap<Arc, Value>, ValueArcMap, ValueNodeMap>
-        circ(_graph, low, cap, sup);
-      if (!circ.flowMap(flow).run()) return INFEASIBLE;
-
-      // Set residual capacities and handle GEQ supply type
-      if (_sum_supply < 0) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-          sup[_graph.source(a)] -= fa;
-          sup[_graph.target(a)] += fa;
-        }
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          _excess[_node_id[n]] = sup[n];
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int u = _target[a];
-          int ra = _reverse[a];
-          _res_cap[a] = -_sum_supply + 1;
-          _res_cap[ra] = -_excess[u];
-          _cost[a] = 0;
-          _cost[ra] = 0;
-          _excess[u] = 0;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = 0;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      }
-
-      // Initialize data structures for buckets
-      _max_rank = _alpha * _res_node_num;
-      _buckets.resize(_max_rank);
-      _bucket_next.resize(_res_node_num + 1);
-      _bucket_prev.resize(_res_node_num + 1);
-      _rank.resize(_res_node_num + 1);
-
-      return OPTIMAL;
-    }
-    
-    // Check if the upper bound is greater or equal to the lower bound
-    // on each arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_upper[j] < _lower[j]) return false;
-      }
-      return true;
-    }
-
-    // Execute the algorithm and transform the results
-    void start(Method method) {
-      const int MAX_PARTIAL_PATH_LENGTH = 4;
-
-      switch (method) {
-        case PUSH:
-          startPush();
-          break;
-        case AUGMENT:
-          startAugment(_res_node_num - 1);
-          break;
-        case PARTIAL_AUGMENT:
-          startAugment(MAX_PARTIAL_PATH_LENGTH);
-          break;
-      }
-
-      // Compute node potentials (dual solution)
-      for (int i = 0; i != _res_node_num; ++i) {
-        _pi[i] = static_cast<Cost>(_pi[i] / (_res_node_num * _alpha));
-      }
-      bool optimal = true;
-      for (int i = 0; optimal && i != _res_node_num; ++i) {
-        LargeCost pi_i = _pi[i];
-        int last_out = _first_out[i+1];
-        for (int j = _first_out[i]; j != last_out; ++j) {
-          if (_res_cap[j] > 0 && _scost[j] + pi_i - _pi[_target[j]] < 0) {
-            optimal = false;
-            break;
-          }
-        }
-      }
-
-      if (!optimal) {
-        // Compute node potentials for the original costs with BellmanFord
-        // (if it is necessary)
-        typedef std::pair<int, int> IntPair;
-        StaticDigraph sgr;
-        std::vector<IntPair> arc_vec;
-        std::vector<LargeCost> cost_vec;
-        LargeCostArcMap cost_map(cost_vec);
-
-        arc_vec.clear();
-        cost_vec.clear();
-        for (int j = 0; j != _res_arc_num; ++j) {
-          if (_res_cap[j] > 0) {
-            int u = _source[j], v = _target[j];
-            arc_vec.push_back(IntPair(u, v));
-            cost_vec.push_back(_scost[j] + _pi[u] - _pi[v]);
-          }
-        }
-        sgr.build(_res_node_num, arc_vec.begin(), arc_vec.end());
-
-        typename BellmanFord<StaticDigraph, LargeCostArcMap>::Create
-          bf(sgr, cost_map);
-        bf.init(0);
-        bf.start();
-
-        for (int i = 0; i != _res_node_num; ++i) {
-          _pi[i] += bf.dist(sgr.node(i));
-        }
-      }
-
-      // Shift potentials to meet the requirements of the GEQ type
-      // optimality conditions
-      LargeCost max_pot = _pi[_root];
-      for (int i = 0; i != _res_node_num; ++i) {
-        if (_pi[i] > max_pot) max_pot = _pi[i];
-      }
-      if (max_pot != 0) {
-        for (int i = 0; i != _res_node_num; ++i) {
-          _pi[i] -= max_pot;
-        }
-      }
-
-      // Handle non-zero lower bounds
-      if (_have_lower) {
-        int limit = _first_out[_root];
-        for (int j = 0; j != limit; ++j) {
-          if (!_forward[j]) _res_cap[j] += _lower[j];
-        }
-      }
-    }
-
-    // Initialize a cost scaling phase
-    void initPhase() {
-      // Saturate arcs not satisfying the optimality condition
-      for (int u = 0; u != _res_node_num; ++u) {
-        int last_out = _first_out[u+1];
-        LargeCost pi_u = _pi[u];
-        for (int a = _first_out[u]; a != last_out; ++a) {
-          Value delta = _res_cap[a];
-          if (delta > 0) {
-            int v = _target[a];
-            if (_cost[a] + pi_u - _pi[v] < 0) {
-              _excess[u] -= delta;
-              _excess[v] += delta;
-              _res_cap[a] = 0;
-              _res_cap[_reverse[a]] += delta;
-            }
-          }
-        }
-      }
-
-      // Find active nodes (i.e. nodes with positive excess)
-      for (int u = 0; u != _res_node_num; ++u) {
-        if (_excess[u] > 0) _active_nodes.push_back(u);
-      }
-
-      // Initialize the next arcs
-      for (int u = 0; u != _res_node_num; ++u) {
-        _next_out[u] = _first_out[u];
-      }
-    }
-
-    // Price (potential) refinement heuristic
-    bool priceRefinement() {
-
-      // Stack for stroing the topological order
-      IntVector stack(_res_node_num);
-      int stack_top;
-
-      // Perform phases
-      while (topologicalSort(stack, stack_top)) {
-
-        // Compute node ranks in the acyclic admissible network and
-        // store the nodes in buckets
-        for (int i = 0; i != _res_node_num; ++i) {
-          _rank[i] = 0;
-        }
-        const int bucket_end = _root + 1;
-        for (int r = 0; r != _max_rank; ++r) {
-          _buckets[r] = bucket_end;
-        }
-        int top_rank = 0;
-        for ( ; stack_top >= 0; --stack_top) {
-          int u = stack[stack_top], v;
-          int rank_u = _rank[u];
-
-          LargeCost rc, pi_u = _pi[u];
-          int last_out = _first_out[u+1];
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            if (_res_cap[a] > 0) {
-              v = _target[a];
-              rc = _cost[a] + pi_u - _pi[v];
-              if (rc < 0) {
-                LargeCost nrc = static_cast<LargeCost>((-rc - 0.5) / _epsilon);
-                if (nrc < LargeCost(_max_rank)) {
-                  int new_rank_v = rank_u + static_cast<int>(nrc);
-                  if (new_rank_v > _rank[v]) {
-                    _rank[v] = new_rank_v;
-                  }
-                }
-              }
-            }
-          }
-
-          if (rank_u > 0) {
-            top_rank = std::max(top_rank, rank_u);
-            int bfirst = _buckets[rank_u];
-            _bucket_next[u] = bfirst;
-            _bucket_prev[bfirst] = u;
-            _buckets[rank_u] = u;
-          }
-        }
-
-        // Check if the current flow is epsilon-optimal
-        if (top_rank == 0) {
-          return true;
-        }
-
-        // Process buckets in top-down order
-        for (int rank = top_rank; rank > 0; --rank) {
-          while (_buckets[rank] != bucket_end) {
-            // Remove the first node from the current bucket
-            int u = _buckets[rank];
-            _buckets[rank] = _bucket_next[u];
-
-            // Search the outgoing arcs of u
-            LargeCost rc, pi_u = _pi[u];
-            int last_out = _first_out[u+1];
-            int v, old_rank_v, new_rank_v;
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                v = _target[a];
-                old_rank_v = _rank[v];
-
-                if (old_rank_v < rank) {
-
-                  // Compute the new rank of node v
-                  rc = _cost[a] + pi_u - _pi[v];
-                  if (rc < 0) {
-                    new_rank_v = rank;
-                  } else {
-                    LargeCost nrc = rc / _epsilon;
-                    new_rank_v = 0;
-                    if (nrc < LargeCost(_max_rank)) {
-                      new_rank_v = rank - 1 - static_cast<int>(nrc);
-                    }
-                  }
-
-                  // Change the rank of node v
-                  if (new_rank_v > old_rank_v) {
-                    _rank[v] = new_rank_v;
-
-                    // Remove v from its old bucket
-                    if (old_rank_v > 0) {
-                      if (_buckets[old_rank_v] == v) {
-                        _buckets[old_rank_v] = _bucket_next[v];
-                      } else {
-                        int pv = _bucket_prev[v], nv = _bucket_next[v];
-                        _bucket_next[pv] = nv;
-                        _bucket_prev[nv] = pv;
-                      }
-                    }
-
-                    // Insert v into its new bucket
-                    int nv = _buckets[new_rank_v];
-                    _bucket_next[v] = nv;
-                    _bucket_prev[nv] = v;
-                    _buckets[new_rank_v] = v;
-                  }
-                }
-              }
-            }
-
-            // Refine potential of node u
-            _pi[u] -= rank * _epsilon;
-          }
-        }
-
-      }
-
-      return false;
-    }
-
-    // Find and cancel cycles in the admissible network and
-    // determine topological order using DFS
-    bool topologicalSort(IntVector &stack, int &stack_top) {
-      const int MAX_CYCLE_CANCEL = 1;
-
-      BoolVector reached(_res_node_num, false);
-      BoolVector processed(_res_node_num, false);
-      IntVector pred(_res_node_num);
-      for (int i = 0; i != _res_node_num; ++i) {
-        _next_out[i] = _first_out[i];
-      }
-      stack_top = -1;
-
-      int cycle_cnt = 0;
-      for (int start = 0; start != _res_node_num; ++start) {
-        if (reached[start]) continue;
-
-        // Start DFS search from this start node
-        pred[start] = -1;
-        int tip = start, v;
-        while (true) {
-          // Check the outgoing arcs of the current tip node
-          reached[tip] = true;
-          LargeCost pi_tip = _pi[tip];
-          int a, last_out = _first_out[tip+1];
-          for (a = _next_out[tip]; a != last_out; ++a) {
-            if (_res_cap[a] > 0) {
-              v = _target[a];
-              if (_cost[a] + pi_tip - _pi[v] < 0) {
-                if (!reached[v]) {
-                  // A new node is reached
-                  reached[v] = true;
-                  pred[v] = tip;
-                  _next_out[tip] = a;
-                  tip = v;
-                  a = _next_out[tip];
-                  last_out = _first_out[tip+1];
-                  break;
-                }
-                else if (!processed[v]) {
-                  // A cycle is found
-                  ++cycle_cnt;
-                  _next_out[tip] = a;
-
-                  // Find the minimum residual capacity along the cycle
-                  Value d, delta = _res_cap[a];
-                  int u, delta_node = tip;
-                  for (u = tip; u != v; ) {
-                    u = pred[u];
-                    d = _res_cap[_next_out[u]];
-                    if (d <= delta) {
-                      delta = d;
-                      delta_node = u;
-                    }
-                  }
-
-                  // Augment along the cycle
-                  _res_cap[a] -= delta;
-                  _res_cap[_reverse[a]] += delta;
-                  for (u = tip; u != v; ) {
-                    u = pred[u];
-                    int ca = _next_out[u];
-                    _res_cap[ca] -= delta;
-                    _res_cap[_reverse[ca]] += delta;
-                  }
-
-                  // Check the maximum number of cycle canceling
-                  if (cycle_cnt >= MAX_CYCLE_CANCEL) {
-                    return false;
-                  }
-
-                  // Roll back search to delta_node
-                  if (delta_node != tip) {
-                    for (u = tip; u != delta_node; u = pred[u]) {
-                      reached[u] = false;
-                    }
-                    tip = delta_node;
-                    a = _next_out[tip] + 1;
-                    last_out = _first_out[tip+1];
-                    break;
-                  }
-                }
-              }
-            }
-          }
-
-          // Step back to the previous node
-          if (a == last_out) {
-            processed[tip] = true;
-            stack[++stack_top] = tip;
-            tip = pred[tip];
-            if (tip < 0) {
-              // Finish DFS from the current start node
-              break;
-            }
-            ++_next_out[tip];
-          }
-        }
-
-      }
-
-      return (cycle_cnt == 0);
-    }
-
-    // Global potential update heuristic
-    void globalUpdate() {
-      const int bucket_end = _root + 1;
-
-      // Initialize buckets
-      for (int r = 0; r != _max_rank; ++r) {
-        _buckets[r] = bucket_end;
-      }
-      Value total_excess = 0;
-      int b0 = bucket_end;
-      for (int i = 0; i != _res_node_num; ++i) {
-        if (_excess[i] < 0) {
-          _rank[i] = 0;
-          _bucket_next[i] = b0;
-          _bucket_prev[b0] = i;
-          b0 = i;
-        } else {
-          total_excess += _excess[i];
-          _rank[i] = _max_rank;
-        }
-      }
-      if (total_excess == 0) return;
-      _buckets[0] = b0;
-
-      // Search the buckets
-      int r = 0;
-      for ( ; r != _max_rank; ++r) {
-        while (_buckets[r] != bucket_end) {
-          // Remove the first node from the current bucket
-          int u = _buckets[r];
-          _buckets[r] = _bucket_next[u];
-
-          // Search the incoming arcs of u
-          LargeCost pi_u = _pi[u];
-          int last_out = _first_out[u+1];
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            int ra = _reverse[a];
-            if (_res_cap[ra] > 0) {
-              int v = _source[ra];
-              int old_rank_v = _rank[v];
-              if (r < old_rank_v) {
-                // Compute the new rank of v
-                LargeCost nrc = (_cost[ra] + _pi[v] - pi_u) / _epsilon;
-                int new_rank_v = old_rank_v;
-                if (nrc < LargeCost(_max_rank)) {
-                  new_rank_v = r + 1 + static_cast<int>(nrc);
-                }
-
-                // Change the rank of v
-                if (new_rank_v < old_rank_v) {
-                  _rank[v] = new_rank_v;
-                  _next_out[v] = _first_out[v];
-
-                  // Remove v from its old bucket
-                  if (old_rank_v < _max_rank) {
-                    if (_buckets[old_rank_v] == v) {
-                      _buckets[old_rank_v] = _bucket_next[v];
-                    } else {
-                      int pv = _bucket_prev[v], nv = _bucket_next[v];
-                      _bucket_next[pv] = nv;
-                      _bucket_prev[nv] = pv;
-                    }
-                  }
-
-                  // Insert v into its new bucket
-                  int nv = _buckets[new_rank_v];
-                  _bucket_next[v] = nv;
-                  _bucket_prev[nv] = v;
-                  _buckets[new_rank_v] = v;
-                }
-              }
-            }
-          }
-
-          // Finish search if there are no more active nodes
-          if (_excess[u] > 0) {
-            total_excess -= _excess[u];
-            if (total_excess <= 0) break;
-          }
-        }
-        if (total_excess <= 0) break;
-      }
-
-      // Relabel nodes
-      for (int u = 0; u != _res_node_num; ++u) {
-        int k = std::min(_rank[u], r);
-        if (k > 0) {
-          _pi[u] -= _epsilon * k;
-          _next_out[u] = _first_out[u];
-        }
-      }
-    }
-
-    /// Execute the algorithm performing augment and relabel operations
-    void startAugment(int max_length) {
-      // Paramters for heuristics
-      const int PRICE_REFINEMENT_LIMIT = 2;
-      const double GLOBAL_UPDATE_FACTOR = 1.0;
-      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_global_update_limit = global_update_skip;
-
-      // Perform cost scaling phases
-      IntVector path;
-      BoolVector path_arc(_res_arc_num, false);
-      int relabel_cnt = 0;
-      int eps_phase_cnt = 0;
-      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
-                                        1 : _epsilon / _alpha )
-      {
-        ++eps_phase_cnt;
-
-        // Price refinement heuristic
-        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
-          if (priceRefinement()) continue;
-        }
-
-        // Initialize current phase
-        initPhase();
-
-        // Perform partial augment and relabel operations
-        while (true) {
-          // Select an active node (FIFO selection)
-          while (_active_nodes.size() > 0 &&
-                 _excess[_active_nodes.front()] <= 0) {
-            _active_nodes.pop_front();
-          }
-          if (_active_nodes.size() == 0) break;
-          int start = _active_nodes.front();
-
-          // Find an augmenting path from the start node
-          int tip = start;
-          while (int(path.size()) < max_length && _excess[tip] >= 0) {
-            int u;
-            LargeCost rc, min_red_cost = std::numeric_limits<LargeCost>::max();
-            LargeCost pi_tip = _pi[tip];
-            int last_out = _first_out[tip+1];
-            for (int a = _next_out[tip]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                u = _target[a];
-                rc = _cost[a] + pi_tip - _pi[u];
-                if (rc < 0) {
-                  path.push_back(a);
-                  _next_out[tip] = a;
-                  if (path_arc[a]) {
-                    goto augment;   // a cycle is found, stop path search
-                  }
-                  tip = u;
-                  path_arc[a] = true;
-                  goto next_step;
-                }
-                else if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
-              }
-            }
-
-            // Relabel tip node
-            if (tip != start) {
-              int ra = _reverse[path.back()];
-              min_red_cost =
-                std::min(min_red_cost, _cost[ra] + pi_tip - _pi[_target[ra]]);
-            }
-            last_out = _next_out[tip];
-            for (int a = _first_out[tip]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                rc = _cost[a] + pi_tip - _pi[_target[a]];
-                if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
-              }
-            }
-            _pi[tip] -= min_red_cost + _epsilon;
-            _next_out[tip] = _first_out[tip];
-            ++relabel_cnt;
-
-            // Step back
-            if (tip != start) {
-              int pa = path.back();
-              path_arc[pa] = false;
-              tip = _source[pa];
-              path.pop_back();
-            }
-
-          next_step: ;
-          }
-
-          // Augment along the found path (as much flow as possible)
-        augment:
-          Value delta;
-          int pa, u, v = start;
-          for (int i = 0; i != int(path.size()); ++i) {
-            pa = path[i];
-            u = v;
-            v = _target[pa];
-            path_arc[pa] = false;
-            delta = std::min(_res_cap[pa], _excess[u]);
-            _res_cap[pa] -= delta;
-            _res_cap[_reverse[pa]] += delta;
-            _excess[u] -= delta;
-            _excess[v] += delta;
-            if (_excess[v] > 0 && _excess[v] <= delta) {
-              _active_nodes.push_back(v);
-            }
-          }
-          path.clear();
-
-          // Global update heuristic
-          if (relabel_cnt >= next_global_update_limit) {
-            globalUpdate();
-            next_global_update_limit += global_update_skip;
-          }
-        }
-
-      }
-
-    }
-
-    /// Execute the algorithm performing push and relabel operations
-    void startPush() {
-      // Paramters for heuristics
-      const int PRICE_REFINEMENT_LIMIT = 2;
-      const double GLOBAL_UPDATE_FACTOR = 2.0;
-
-      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_global_update_limit = global_update_skip;
-
-      // Perform cost scaling phases
-      BoolVector hyper(_res_node_num, false);
-      LargeCostVector hyper_cost(_res_node_num);
-      int relabel_cnt = 0;
-      int eps_phase_cnt = 0;
-      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
-                                        1 : _epsilon / _alpha )
-      {
-        ++eps_phase_cnt;
-
-        // Price refinement heuristic
-        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
-          if (priceRefinement()) continue;
-        }
-
-        // Initialize current phase
-        initPhase();
-
-        // Perform push and relabel operations
-        while (_active_nodes.size() > 0) {
-          LargeCost min_red_cost, rc, pi_n;
-          Value delta;
-          int n, t, a, last_out = _res_arc_num;
-
-        next_node:
-          // Select an active node (FIFO selection)
-          n = _active_nodes.front();
-          last_out = _first_out[n+1];
-          pi_n = _pi[n];
-
-          // Perform push operations if there are admissible arcs
-          if (_excess[n] > 0) {
-            for (a = _next_out[n]; a != last_out; ++a) {
-              if (_res_cap[a] > 0 &&
-                  _cost[a] + pi_n - _pi[_target[a]] < 0) {
-                delta = std::min(_res_cap[a], _excess[n]);
-                t = _target[a];
-
-                // Push-look-ahead heuristic
-                Value ahead = -_excess[t];
-                int last_out_t = _first_out[t+1];
-                LargeCost pi_t = _pi[t];
-                for (int ta = _next_out[t]; ta != last_out_t; ++ta) {
-                  if (_res_cap[ta] > 0 &&
-                      _cost[ta] + pi_t - _pi[_target[ta]] < 0)
-                    ahead += _res_cap[ta];
-                  if (ahead >= delta) break;
-                }
-                if (ahead < 0) ahead = 0;
-
-                // Push flow along the arc
-                if (ahead < delta && !hyper[t]) {
-                  _res_cap[a] -= ahead;
-                  _res_cap[_reverse[a]] += ahead;
-                  _excess[n] -= ahead;
-                  _excess[t] += ahead;
-                  _active_nodes.push_front(t);
-                  hyper[t] = true;
-                  hyper_cost[t] = _cost[a] + pi_n - pi_t;
-                  _next_out[n] = a;
-                  goto next_node;
-                } else {
-                  _res_cap[a] -= delta;
-                  _res_cap[_reverse[a]] += delta;
-                  _excess[n] -= delta;
-                  _excess[t] += delta;
-                  if (_excess[t] > 0 && _excess[t] <= delta)
-                    _active_nodes.push_back(t);
-                }
-
-                if (_excess[n] == 0) {
-                  _next_out[n] = a;
-                  goto remove_nodes;
-                }
-              }
-            }
-            _next_out[n] = a;
-          }
-
-          // Relabel the node if it is still active (or hyper)
-          if (_excess[n] > 0 || hyper[n]) {
-             min_red_cost = hyper[n] ? -hyper_cost[n] :
-               std::numeric_limits<LargeCost>::max();
-            for (int a = _first_out[n]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                rc = _cost[a] + pi_n - _pi[_target[a]];
-                if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
-              }
-            }
-            _pi[n] -= min_red_cost + _epsilon;
-            _next_out[n] = _first_out[n];
-            hyper[n] = false;
-            ++relabel_cnt;
-          }
-
-          // Remove nodes that are not active nor hyper
-        remove_nodes:
-          while ( _active_nodes.size() > 0 &&
-                  _excess[_active_nodes.front()] <= 0 &&
-                  !hyper[_active_nodes.front()] ) {
-            _active_nodes.pop_front();
-          }
-
-          // Global update heuristic
-          if (relabel_cnt >= next_global_update_limit) {
-            globalUpdate();
-            for (int u = 0; u != _res_node_num; ++u)
-              hyper[u] = false;
-            next_global_update_limit += global_update_skip;
-          }
-        }
-      }
-    }
-
-  }; //class CostScaling
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_COST_SCALING_H
Index: lemon/counter.h
===================================================================
--- lemon/counter.h	(revision 833)
+++ lemon/counter.h	(revision 463)
@@ -213,5 +213,5 @@
   /// 'Do nothing' version of Counter.
 
-  /// This class can be used in the same way as \ref Counter, but it
+  /// This class can be used in the same way as \ref Counter however it
   /// does not count at all and does not print report on destruction.
   ///
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 1231)
+++ lemon/cplex.cc	(revision 1181)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -113,37 +113,4 @@
   }
 
-  int CplexBase::_addRow(Value lb, ExprIterator b,
-                         ExprIterator e, Value ub) {
-    int i = CPXgetnumrows(cplexEnv(), _prob);
-    if (lb == -INF) {
-      const char s = 'L';
-      CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
-    } else if (ub == INF) {
-      const char s = 'G';
-      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
-    } else if (lb == ub){
-      const char s = 'E';
-      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
-    } else {
-      const char s = 'R';
-      double len = ub - lb;
-      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
-    }
-
-    std::vector<int> indices;
-    std::vector<int> rowlist;
-    std::vector<Value> values;
-
-    for(ExprIterator it=b; it!=e; ++it) {
-      indices.push_back(it->first);
-      values.push_back(it->second);
-      rowlist.push_back(i);
-    }
-
-    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
-                   &rowlist.front(), &indices.front(), &values.front());
-
-    return i;
-  }
 
   void CplexBase::_eraseCol(int i) {
@@ -489,18 +456,7 @@
 
   void CplexBase::_applyMessageLevel() {
-    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
+    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, 
                    _message_enabled ? CPX_ON : CPX_OFF);
   }
-
-  void CplexBase::_write(std::string file, std::string format) const
-  {
-    if(format == "MPS" || format == "LP")
-      CPXwriteprob(cplexEnv(), cplexLp(), file.c_str(), format.c_str());
-    else if(format == "SOL")
-      CPXsolwrite(cplexEnv(), cplexLp(), file.c_str());
-    else throw UnsupportedFormatError(format);
-  }
-
-
 
   // CplexLp members
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 1250)
+++ lemon/cplex.h	(revision 623)
@@ -94,5 +94,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
@@ -150,6 +149,4 @@
 
     bool _message_enabled;
-
-    void _write(std::string file, std::string format) const;
 
   public:
@@ -173,17 +170,4 @@
     const cpxlp* cplexLp() const { return _prob; }
 
-#ifdef DOXYGEN
-    /// Write the problem or the solution to a file in the given format
-
-    /// This function writes the problem or the solution
-    /// to a file in the given format.
-    /// Trying to write in an unsupported format will trigger
-    /// \ref lemon::LpBase::UnsupportedFormatError "UnsupportedFormatError".
-    /// \param file The file path
-    /// \param format The output file format.
-    /// Supportted formats are "MPS", "LP" and "SOL".
-    void write(std::string file, std::string format = "MPS") const {}
-#endif
-
   };
 
Index: lemon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 1255)
+++ 	(revision )
@@ -1,1231 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_CYCLE_CANCELING_H
-#define LEMON_CYCLE_CANCELING_H
-
-/// \ingroup min_cost_flow_algs
-/// \file
-/// \brief Cycle-canceling algorithms for finding a minimum cost flow.
-
-#include <vector>
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/maps.h>
-#include <lemon/path.h>
-#include <lemon/math.h>
-#include <lemon/static_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/circulation.h>
-#include <lemon/bellman_ford.h>
-#include <lemon/howard_mmc.h>
-#include <lemon/hartmann_orlin_mmc.h>
-
-namespace lemon {
-
-  /// \addtogroup min_cost_flow_algs
-  /// @{
-
-  /// \brief Implementation of cycle-canceling algorithms for
-  /// finding a \ref min_cost_flow "minimum cost flow".
-  ///
-  /// \ref CycleCanceling implements three different cycle-canceling
-  /// algorithms for finding a \ref min_cost_flow "minimum cost flow"
-  /// \cite amo93networkflows, \cite klein67primal,
-  /// \cite goldberg89cyclecanceling.
-  /// The most efficent one is the \ref CANCEL_AND_TIGHTEN
-  /// "Cancel-and-Tighten" algorithm, thus it is the default method.
-  /// It runs in strongly polynomial time \f$O(n^2 m^2 \log n)\f$,
-  /// but in practice, it is typically orders of magnitude slower than
-  /// the scaling algorithms and \ref NetworkSimplex.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
-  ///
-  /// Most of the parameters of the problem (except for the digraph)
-  /// can be given using separate functions, and the algorithm can be
-  /// executed using the \ref run() function. If some parameters are not
-  /// specified, then default values will be used.
-  ///
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
-  /// be integer.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
-  ///
-  /// \note For more information about the three available methods,
-  /// see \ref Method.
-#ifdef DOXYGEN
-  template <typename GR, typename V, typename C>
-#else
-  template <typename GR, typename V = int, typename C = V>
-#endif
-  class CycleCanceling
-  {
-  public:
-
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef V Value;
-    /// The type of the arc costs
-    typedef C Cost;
-
-  public:
-
-    /// \brief Problem type constants for the \c run() function.
-    ///
-    /// Enum type containing the problem type constants that can be
-    /// returned by the \ref run() function of the algorithm.
-    enum ProblemType {
-      /// The problem has no feasible solution (flow).
-      INFEASIBLE,
-      /// The problem has optimal solution (i.e. it is feasible and
-      /// bounded), and the algorithm has found optimal flow and node
-      /// potentials (primal and dual solutions).
-      OPTIMAL,
-      /// The digraph contains an arc of negative cost and infinite
-      /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however, note that it could actually be bounded
-      /// over the feasible flows, but this algroithm cannot handle
-      /// these cases.
-      UNBOUNDED
-    };
-
-    /// \brief Constants for selecting the used method.
-    ///
-    /// Enum type containing constants for selecting the used method
-    /// for the \ref run() function.
-    ///
-    /// \ref CycleCanceling provides three different cycle-canceling
-    /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel-and-Tighten"
-    /// is used, which is by far the most efficient and the most robust.
-    /// However, the other methods can be selected using the \ref run()
-    /// function with the proper parameter.
-    enum Method {
-      /// A simple cycle-canceling method, which uses the
-      /// \ref BellmanFord "Bellman-Ford" algorithm for detecting negative
-      /// cycles in the residual network.
-      /// The number of Bellman-Ford iterations is bounded by a successively
-      /// increased limit.
-      SIMPLE_CYCLE_CANCELING,
-      /// The "Minimum Mean Cycle-Canceling" algorithm, which is a
-      /// well-known strongly polynomial method
-      /// \cite goldberg89cyclecanceling. It improves along a
-      /// \ref min_mean_cycle "minimum mean cycle" in each iteration.
-      /// Its running time complexity is \f$O(n^2 m^3 \log n)\f$.
-      MINIMUM_MEAN_CYCLE_CANCELING,
-      /// The "Cancel-and-Tighten" algorithm, which can be viewed as an
-      /// improved version of the previous method
-      /// \cite goldberg89cyclecanceling.
-      /// It is faster both in theory and in practice, its running time
-      /// complexity is \f$O(n^2 m^2 \log n)\f$.
-      CANCEL_AND_TIGHTEN
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<double> DoubleVector;
-    typedef std::vector<Value> ValueVector;
-    typedef std::vector<Cost> CostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-  private:
-
-    template <typename KT, typename VT>
-    class StaticVectorMap {
-    public:
-      typedef KT Key;
-      typedef VT Value;
-
-      StaticVectorMap(std::vector<Value>& v) : _v(v) {}
-
-      const Value& operator[](const Key& key) const {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      Value& operator[](const Key& key) {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      void set(const Key& key, const Value& val) {
-        _v[StaticDigraph::id(key)] = val;
-      }
-
-    private:
-      std::vector<Value>& _v;
-    };
-
-    typedef StaticVectorMap<StaticDigraph::Node, Cost> CostNodeMap;
-    typedef StaticVectorMap<StaticDigraph::Arc, Cost> CostArcMap;
-
-  private:
-
-
-    // Data related to the underlying digraph
-    const GR &_graph;
-    int _node_num;
-    int _arc_num;
-    int _res_node_num;
-    int _res_arc_num;
-    int _root;
-
-    // Parameters of the problem
-    bool _have_lower;
-    Value _sum_supply;
-
-    // Data structures for storing the digraph
-    IntNodeMap _node_id;
-    IntArcMap _arc_idf;
-    IntArcMap _arc_idb;
-    IntVector _first_out;
-    BoolVector _forward;
-    IntVector _source;
-    IntVector _target;
-    IntVector _reverse;
-
-    // Node and arc data
-    ValueVector _lower;
-    ValueVector _upper;
-    CostVector _cost;
-    ValueVector _supply;
-
-    ValueVector _res_cap;
-    CostVector _pi;
-
-    // Data for a StaticDigraph structure
-    typedef std::pair<int, int> IntPair;
-    StaticDigraph _sgr;
-    std::vector<IntPair> _arc_vec;
-    std::vector<Cost> _cost_vec;
-    IntVector _id_vec;
-    CostArcMap _cost_map;
-    CostNodeMap _pi_map;
-
-  public:
-
-    /// \brief Constant for infinite upper bounds (capacities).
-    ///
-    /// Constant for infinite upper bounds (capacities).
-    /// It is \c std::numeric_limits<Value>::infinity() if available,
-    /// \c std::numeric_limits<Value>::max() otherwise.
-    const Value INF;
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    CycleCanceling(const GR& graph) :
-      _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),
-      _cost_map(_cost_vec), _pi_map(_pi),
-      INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() :
-          std::numeric_limits<Value>::max())
-    {
-      // Check the number types
-      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
-        "The flow type of CycleCanceling must be signed");
-      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
-        "The cost type of CycleCanceling must be signed");
-
-      // Reset data structures
-      reset();
-    }
-
-    /// \name Parameters
-    /// The parameters of the algorithm can be specified using these
-    /// functions.
-
-    /// @{
-
-    /// \brief Set the lower bounds on the arcs.
-    ///
-    /// This function sets the lower bounds on the arcs.
-    /// If it is not used before calling \ref run(), the lower bounds
-    /// will be set to zero on all arcs.
-    ///
-    /// \param map An arc map storing the lower bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template <typename LowerMap>
-    CycleCanceling& lowerMap(const LowerMap& map) {
-      _have_lower = true;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _lower[_arc_idf[a]] = map[a];
-        _lower[_arc_idb[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the upper bounds (capacities) on the arcs.
-    ///
-    /// This function sets the upper bounds (capacities) on the arcs.
-    /// If it is not used before calling \ref run(), the upper bounds
-    /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
-    ///
-    /// \param map An arc map storing the upper bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename UpperMap>
-    CycleCanceling& upperMap(const UpperMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _upper[_arc_idf[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the costs of the arcs.
-    ///
-    /// This function sets the costs of the arcs.
-    /// If it is not used before calling \ref run(), the costs
-    /// will be set to \c 1 on all arcs.
-    ///
-    /// \param map An arc map storing the costs.
-    /// Its \c Value type must be convertible to the \c Cost type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename CostMap>
-    CycleCanceling& costMap(const CostMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _cost[_arc_idf[a]] =  map[a];
-        _cost[_arc_idb[a]] = -map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the supply values of the nodes.
-    ///
-    /// This function sets the supply values of the nodes.
-    /// If neither this function nor \ref stSupply() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// \param map A node map storing the supply values.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename SupplyMap>
-    CycleCanceling& supplyMap(const SupplyMap& map) {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _supply[_node_id[n]] = map[n];
-      }
-      return *this;
-    }
-
-    /// \brief Set single source and target nodes and a supply value.
-    ///
-    /// This function sets a single source node and a single target node
-    /// and the required flow value.
-    /// If neither this function nor \ref supplyMap() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
-    /// assigned to \c t and all other nodes have zero supply value.
-    ///
-    /// \param s The source node.
-    /// \param t The target node.
-    /// \param k The required amount of flow from node \c s to node \c t
-    /// (i.e. the supply of \c s and the demand of \c t).
-    ///
-    /// \return <tt>(*this)</tt>
-    CycleCanceling& stSupply(const Node& s, const Node& t, Value k) {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      _supply[_node_id[s]] =  k;
-      _supply[_node_id[t]] = -k;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Execution control
-    /// The algorithm can be executed using \ref run().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    /// For example,
-    /// \code
-    ///   CycleCanceling<ListDigraph> cc(graph);
-    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
-    ///
-    /// \param method The cycle-canceling method that will be used.
-    /// For more information, see \ref Method.
-    ///
-    /// \return \c INFEASIBLE if no feasible flow exists,
-    /// \n \c OPTIMAL if the problem has optimal solution
-    /// (i.e. it is feasible and bounded), and the algorithm has found
-    /// optimal flow and node potentials (primal and dual solutions),
-    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
-    /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however, note that it could actually be
-    /// bounded over the feasible flows, but this algroithm cannot handle
-    /// these cases.
-    ///
-    /// \see ProblemType, Method
-    /// \see resetParams(), reset()
-    ProblemType run(Method method = CANCEL_AND_TIGHTEN) {
-      ProblemType pt = init();
-      if (pt != OPTIMAL) return pt;
-      start(method);
-      return OPTIMAL;
-    }
-
-    /// \brief Reset all the parameters that have been given before.
-    ///
-    /// This function resets all the paramaters that have been given
-    /// before using functions \ref lowerMap(), \ref upperMap(),
-    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// For example,
-    /// \code
-    ///   CycleCanceling<ListDigraph> cs(graph);
-    ///
-    ///   // First run
-    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    ///
-    ///   // Run again with modified cost map (resetParams() is not called,
-    ///   // so only the cost map have to be set again)
-    ///   cost[e] += 100;
-    ///   cc.costMap(cost).run();
-    ///
-    ///   // Run again from scratch using resetParams()
-    ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cc.resetParams();
-    ///   cc.upperMap(capacity).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CycleCanceling& resetParams() {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      int limit = _first_out[_root];
-      for (int j = 0; j != limit; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _cost[j] = _forward[j] ? 1 : -1;
-      }
-      for (int j = limit; j != _res_arc_num; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _cost[j] = 0;
-        _cost[_reverse[j]] = 0;
-      }
-      _have_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CycleCanceling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_node_num = _node_num + 1;
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-
-      _first_out.resize(_res_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _supply.resize(_res_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _pi.resize(_res_node_num);
-
-      _arc_vec.reserve(_res_arc_num);
-      _cost_vec.reserve(_res_arc_num);
-      _id_vec.reserve(_res_arc_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_res_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The \ref run() function must be called before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found flow.
-    ///
-    /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
-    ///
-    /// \note The return type of the function can be specified as a
-    /// template parameter. For example,
-    /// \code
-    ///   cc.totalCost<double>();
-    /// \endcode
-    /// It is useful if the total cost cannot be stored in the \c Cost
-    /// type of the algorithm, which is the default return type of the
-    /// function.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename Number>
-    Number totalCost() const {
-      Number c = 0;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int i = _arc_idb[a];
-        c += static_cast<Number>(_res_cap[i]) *
-             (-static_cast<Number>(_cost[i]));
-      }
-      return c;
-    }
-
-#ifndef DOXYGEN
-    Cost totalCost() const {
-      return totalCost<Cost>();
-    }
-#endif
-
-    /// \brief Return the flow on the given arc.
-    ///
-    /// This function returns the flow on the given arc.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value flow(const Arc& a) const {
-      return _res_cap[_arc_idb[a]];
-    }
-
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
-    ///
-    /// This function copies the flow value on each arc into the given
-    /// map. The \c Value type of the algorithm must be convertible to
-    /// the \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename FlowMap>
-    void flowMap(FlowMap &map) const {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        map.set(a, _res_cap[_arc_idb[a]]);
-      }
-    }
-
-    /// \brief Return the potential (dual value) of the given node.
-    ///
-    /// This function returns the potential (dual value) of the
-    /// given node.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Cost potential(const Node& n) const {
-      return static_cast<Cost>(_pi[_node_id[n]]);
-    }
-
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
-    ///
-    /// This function copies the potential (dual value) of each node
-    /// into the given map.
-    /// The \c Cost type of the algorithm must be convertible to the
-    /// \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename PotentialMap>
-    void potentialMap(PotentialMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map.set(n, static_cast<Cost>(_pi[_node_id[n]]));
-      }
-    }
-
-    /// @}
-
-  private:
-
-    // Initialize the algorithm
-    ProblemType init() {
-      if (_res_node_num <= 1) return INFEASIBLE;
-
-      // Check the sum of supply values
-      _sum_supply = 0;
-      for (int i = 0; i != _root; ++i) {
-        _sum_supply += _supply[i];
-      }
-      if (_sum_supply > 0) return INFEASIBLE;
-
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
-
-      // Initialize vectors
-      for (int i = 0; i != _res_node_num; ++i) {
-        _pi[i] = 0;
-      }
-      ValueVector excess(_supply);
-
-      // Remove infinite upper bounds and check negative arcs
-      const Value MAX = std::numeric_limits<Value>::max();
-      int last_out;
-      if (_have_lower) {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j]) {
-              Value c = _cost[j] < 0 ? _upper[j] : _lower[j];
-              if (c >= MAX) return UNBOUNDED;
-              excess[i] -= c;
-              excess[_target[j]] += c;
-            }
-          }
-        }
-      } else {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j] && _cost[j] < 0) {
-              Value c = _upper[j];
-              if (c >= MAX) return UNBOUNDED;
-              excess[i] -= c;
-              excess[_target[j]] += c;
-            }
-          }
-        }
-      }
-      Value ex, max_cap = 0;
-      for (int i = 0; i != _res_node_num; ++i) {
-        ex = excess[i];
-        if (ex < 0) max_cap -= ex;
-      }
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_upper[j] >= MAX) _upper[j] = max_cap;
-      }
-
-      // Initialize maps for Circulation and remove non-zero lower bounds
-      ConstMap<Arc, Value> low(0);
-      typedef typename Digraph::template ArcMap<Value> ValueArcMap;
-      typedef typename Digraph::template NodeMap<Value> ValueNodeMap;
-      ValueArcMap cap(_graph), flow(_graph);
-      ValueNodeMap sup(_graph);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sup[n] = _supply[_node_id[n]];
-      }
-      if (_have_lower) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          int j = _arc_idf[a];
-          Value c = _lower[j];
-          cap[a] = _upper[j] - c;
-          sup[_graph.source(a)] -= c;
-          sup[_graph.target(a)] += c;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          cap[a] = _upper[_arc_idf[a]];
-        }
-      }
-
-      // Find a feasible flow using Circulation
-      Circulation<Digraph, ConstMap<Arc, Value>, ValueArcMap, ValueNodeMap>
-        circ(_graph, low, cap, sup);
-      if (!circ.flowMap(flow).run()) return INFEASIBLE;
-
-      // Set residual capacities and handle GEQ supply type
-      if (_sum_supply < 0) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-          sup[_graph.source(a)] -= fa;
-          sup[_graph.target(a)] += fa;
-        }
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          excess[_node_id[n]] = sup[n];
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int u = _target[a];
-          int ra = _reverse[a];
-          _res_cap[a] = -_sum_supply + 1;
-          _res_cap[ra] = -excess[u];
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = 1;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      }
-
-      return OPTIMAL;
-    }
-    
-    // Check if the upper bound is greater or equal to the lower bound
-    // on each arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_upper[j] < _lower[j]) return false;
-      }
-      return true;
-    }
-
-    // Build a StaticDigraph structure containing the current
-    // residual network
-    void buildResidualNetwork() {
-      _arc_vec.clear();
-      _cost_vec.clear();
-      _id_vec.clear();
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_res_cap[j] > 0) {
-          _arc_vec.push_back(IntPair(_source[j], _target[j]));
-          _cost_vec.push_back(_cost[j]);
-          _id_vec.push_back(j);
-        }
-      }
-      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
-    }
-
-    // Execute the algorithm and transform the results
-    void start(Method method) {
-      // Execute the algorithm
-      switch (method) {
-        case SIMPLE_CYCLE_CANCELING:
-          startSimpleCycleCanceling();
-          break;
-        case MINIMUM_MEAN_CYCLE_CANCELING:
-          startMinMeanCycleCanceling();
-          break;
-        case CANCEL_AND_TIGHTEN:
-          startCancelAndTighten();
-          break;
-      }
-
-      // Compute node potentials
-      if (method != SIMPLE_CYCLE_CANCELING) {
-        buildResidualNetwork();
-        typename BellmanFord<StaticDigraph, CostArcMap>
-          ::template SetDistMap<CostNodeMap>::Create bf(_sgr, _cost_map);
-        bf.distMap(_pi_map);
-        bf.init(0);
-        bf.start();
-      }
-
-      // Handle non-zero lower bounds
-      if (_have_lower) {
-        int limit = _first_out[_root];
-        for (int j = 0; j != limit; ++j) {
-          if (!_forward[j]) _res_cap[j] += _lower[j];
-        }
-      }
-    }
-
-    // Execute the "Simple Cycle Canceling" method
-    void startSimpleCycleCanceling() {
-      // Constants for computing the iteration limits
-      const int BF_FIRST_LIMIT  = 2;
-      const double BF_LIMIT_FACTOR = 1.5;
-
-      typedef StaticVectorMap<StaticDigraph::Arc, Value> FilterMap;
-      typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;
-      typedef StaticVectorMap<StaticDigraph::Node, StaticDigraph::Arc> PredMap;
-      typedef typename BellmanFord<ResDigraph, CostArcMap>
-        ::template SetDistMap<CostNodeMap>
-        ::template SetPredMap<PredMap>::Create BF;
-
-      // Build the residual network
-      _arc_vec.clear();
-      _cost_vec.clear();
-      for (int j = 0; j != _res_arc_num; ++j) {
-        _arc_vec.push_back(IntPair(_source[j], _target[j]));
-        _cost_vec.push_back(_cost[j]);
-      }
-      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
-
-      FilterMap filter_map(_res_cap);
-      ResDigraph rgr(_sgr, filter_map);
-      std::vector<int> cycle;
-      std::vector<StaticDigraph::Arc> pred(_res_arc_num);
-      PredMap pred_map(pred);
-      BF bf(rgr, _cost_map);
-      bf.distMap(_pi_map).predMap(pred_map);
-
-      int length_bound = BF_FIRST_LIMIT;
-      bool optimal = false;
-      while (!optimal) {
-        bf.init(0);
-        int iter_num = 0;
-        bool cycle_found = false;
-        while (!cycle_found) {
-          // Perform some iterations of the Bellman-Ford algorithm
-          int curr_iter_num = iter_num + length_bound <= _node_num ?
-            length_bound : _node_num - iter_num;
-          iter_num += curr_iter_num;
-          int real_iter_num = curr_iter_num;
-          for (int i = 0; i < curr_iter_num; ++i) {
-            if (bf.processNextWeakRound()) {
-              real_iter_num = i;
-              break;
-            }
-          }
-          if (real_iter_num < curr_iter_num) {
-            // Optimal flow is found
-            optimal = true;
-            break;
-          } else {
-            // Search for node disjoint negative cycles
-            std::vector<int> state(_res_node_num, 0);
-            int id = 0;
-            for (int u = 0; u != _res_node_num; ++u) {
-              if (state[u] != 0) continue;
-              ++id;
-              int v = u;
-              for (; v != -1 && state[v] == 0; v = pred[v] == INVALID ?
-                   -1 : rgr.id(rgr.source(pred[v]))) {
-                state[v] = id;
-              }
-              if (v != -1 && state[v] == id) {
-                // A negative cycle is found
-                cycle_found = true;
-                cycle.clear();
-                StaticDigraph::Arc a = pred[v];
-                Value d, delta = _res_cap[rgr.id(a)];
-                cycle.push_back(rgr.id(a));
-                while (rgr.id(rgr.source(a)) != v) {
-                  a = pred_map[rgr.source(a)];
-                  d = _res_cap[rgr.id(a)];
-                  if (d < delta) delta = d;
-                  cycle.push_back(rgr.id(a));
-                }
-
-                // Augment along the cycle
-                for (int i = 0; i < int(cycle.size()); ++i) {
-                  int j = cycle[i];
-                  _res_cap[j] -= delta;
-                  _res_cap[_reverse[j]] += delta;
-                }
-              }
-            }
-          }
-
-          // Increase iteration limit if no cycle is found
-          if (!cycle_found) {
-            length_bound = static_cast<int>(length_bound * BF_LIMIT_FACTOR);
-          }
-        }
-      }
-    }
-
-    // Execute the "Minimum Mean Cycle Canceling" method
-    void startMinMeanCycleCanceling() {
-      typedef Path<StaticDigraph> SPath;
-      typedef typename SPath::ArcIt SPathArcIt;
-      typedef typename HowardMmc<StaticDigraph, CostArcMap>
-        ::template SetPath<SPath>::Create HwMmc;
-      typedef typename HartmannOrlinMmc<StaticDigraph, CostArcMap>
-        ::template SetPath<SPath>::Create HoMmc;
-
-      const double HW_ITER_LIMIT_FACTOR = 1.0;
-      const int HW_ITER_LIMIT_MIN_VALUE = 5;
-
-      const int hw_iter_limit =
-          std::max(static_cast<int>(HW_ITER_LIMIT_FACTOR * _node_num),
-                   HW_ITER_LIMIT_MIN_VALUE);
-
-      SPath cycle;
-      HwMmc hw_mmc(_sgr, _cost_map);
-      hw_mmc.cycle(cycle);
-      buildResidualNetwork();
-      while (true) {
-        
-        typename HwMmc::TerminationCause hw_tc =
-            hw_mmc.findCycleMean(hw_iter_limit);
-        if (hw_tc == HwMmc::ITERATION_LIMIT) {
-          // Howard's algorithm reached the iteration limit, start a
-          // strongly polynomial algorithm instead
-          HoMmc ho_mmc(_sgr, _cost_map);
-          ho_mmc.cycle(cycle);
-          // Find a minimum mean cycle (Hartmann-Orlin algorithm)
-          if (!(ho_mmc.findCycleMean() && ho_mmc.cycleCost() < 0)) break;
-          ho_mmc.findCycle();
-        } else {
-          // Find a minimum mean cycle (Howard algorithm)
-          if (!(hw_tc == HwMmc::OPTIMAL && hw_mmc.cycleCost() < 0)) break;
-          hw_mmc.findCycle();
-        }
-        
-        // Compute delta value
-        Value delta = INF;
-        for (SPathArcIt a(cycle); a != INVALID; ++a) {
-          Value d = _res_cap[_id_vec[_sgr.id(a)]];
-          if (d < delta) delta = d;
-        }
-
-        // Augment along the cycle
-        for (SPathArcIt a(cycle); a != INVALID; ++a) {
-          int j = _id_vec[_sgr.id(a)];
-          _res_cap[j] -= delta;
-          _res_cap[_reverse[j]] += delta;
-        }
-
-        // Rebuild the residual network
-        buildResidualNetwork();
-      }
-    }
-
-    // Execute the "Cancel-and-Tighten" method
-    void startCancelAndTighten() {
-      // Constants for the min mean cycle computations
-      const double LIMIT_FACTOR = 1.0;
-      const int MIN_LIMIT = 5;
-      const double HW_ITER_LIMIT_FACTOR = 1.0;
-      const int HW_ITER_LIMIT_MIN_VALUE = 5;
-
-      const int hw_iter_limit =
-          std::max(static_cast<int>(HW_ITER_LIMIT_FACTOR * _node_num),
-                   HW_ITER_LIMIT_MIN_VALUE);
-
-      // Contruct auxiliary data vectors
-      DoubleVector pi(_res_node_num, 0.0);
-      IntVector level(_res_node_num);
-      BoolVector reached(_res_node_num);
-      BoolVector processed(_res_node_num);
-      IntVector pred_node(_res_node_num);
-      IntVector pred_arc(_res_node_num);
-      std::vector<int> stack(_res_node_num);
-      std::vector<int> proc_vector(_res_node_num);
-
-      // Initialize epsilon
-      double epsilon = 0;
-      for (int a = 0; a != _res_arc_num; ++a) {
-        if (_res_cap[a] > 0 && -_cost[a] > epsilon)
-          epsilon = -_cost[a];
-      }
-
-      // Start phases
-      Tolerance<double> tol;
-      tol.epsilon(1e-6);
-      int limit = int(LIMIT_FACTOR * std::sqrt(double(_res_node_num)));
-      if (limit < MIN_LIMIT) limit = MIN_LIMIT;
-      int iter = limit;
-      while (epsilon * _res_node_num >= 1) {
-        // Find and cancel cycles in the admissible network using DFS
-        for (int u = 0; u != _res_node_num; ++u) {
-          reached[u] = false;
-          processed[u] = false;
-        }
-        int stack_head = -1;
-        int proc_head = -1;
-        for (int start = 0; start != _res_node_num; ++start) {
-          if (reached[start]) continue;
-
-          // New start node
-          reached[start] = true;
-          pred_arc[start] = -1;
-          pred_node[start] = -1;
-
-          // Find the first admissible outgoing arc
-          double p = pi[start];
-          int a = _first_out[start];
-          int last_out = _first_out[start+1];
-          for (; a != last_out && (_res_cap[a] == 0 ||
-               !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-          if (a == last_out) {
-            processed[start] = true;
-            proc_vector[++proc_head] = start;
-            continue;
-          }
-          stack[++stack_head] = a;
-
-          while (stack_head >= 0) {
-            int sa = stack[stack_head];
-            int u = _source[sa];
-            int v = _target[sa];
-
-            if (!reached[v]) {
-              // A new node is reached
-              reached[v] = true;
-              pred_node[v] = u;
-              pred_arc[v] = sa;
-              p = pi[v];
-              a = _first_out[v];
-              last_out = _first_out[v+1];
-              for (; a != last_out && (_res_cap[a] == 0 ||
-                   !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-              stack[++stack_head] = a == last_out ? -1 : a;
-            } else {
-              if (!processed[v]) {
-                // A cycle is found
-                int n, w = u;
-                Value d, delta = _res_cap[sa];
-                for (n = u; n != v; n = pred_node[n]) {
-                  d = _res_cap[pred_arc[n]];
-                  if (d <= delta) {
-                    delta = d;
-                    w = pred_node[n];
-                  }
-                }
-
-                // Augment along the cycle
-                _res_cap[sa] -= delta;
-                _res_cap[_reverse[sa]] += delta;
-                for (n = u; n != v; n = pred_node[n]) {
-                  int pa = pred_arc[n];
-                  _res_cap[pa] -= delta;
-                  _res_cap[_reverse[pa]] += delta;
-                }
-                for (n = u; stack_head > 0 && n != w; n = pred_node[n]) {
-                  --stack_head;
-                  reached[n] = false;
-                }
-                u = w;
-              }
-              v = u;
-
-              // Find the next admissible outgoing arc
-              p = pi[v];
-              a = stack[stack_head] + 1;
-              last_out = _first_out[v+1];
-              for (; a != last_out && (_res_cap[a] == 0 ||
-                   !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-              stack[stack_head] = a == last_out ? -1 : a;
-            }
-
-            while (stack_head >= 0 && stack[stack_head] == -1) {
-              processed[v] = true;
-              proc_vector[++proc_head] = v;
-              if (--stack_head >= 0) {
-                // Find the next admissible outgoing arc
-                v = _source[stack[stack_head]];
-                p = pi[v];
-                a = stack[stack_head] + 1;
-                last_out = _first_out[v+1];
-                for (; a != last_out && (_res_cap[a] == 0 ||
-                     !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-                stack[stack_head] = a == last_out ? -1 : a;
-              }
-            }
-          }
-        }
-
-        // Tighten potentials and epsilon
-        if (--iter > 0) {
-          for (int u = 0; u != _res_node_num; ++u) {
-            level[u] = 0;
-          }
-          for (int i = proc_head; i > 0; --i) {
-            int u = proc_vector[i];
-            double p = pi[u];
-            int l = level[u] + 1;
-            int last_out = _first_out[u+1];
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              int v = _target[a];
-              if (_res_cap[a] > 0 && tol.negative(_cost[a] + p - pi[v]) &&
-                  l > level[v]) level[v] = l;
-            }
-          }
-
-          // Modify potentials
-          double q = std::numeric_limits<double>::max();
-          for (int u = 0; u != _res_node_num; ++u) {
-            int lu = level[u];
-            double p, pu = pi[u];
-            int last_out = _first_out[u+1];
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              if (_res_cap[a] == 0) continue;
-              int v = _target[a];
-              int ld = lu - level[v];
-              if (ld > 0) {
-                p = (_cost[a] + pu - pi[v] + epsilon) / (ld + 1);
-                if (p < q) q = p;
-              }
-            }
-          }
-          for (int u = 0; u != _res_node_num; ++u) {
-            pi[u] -= q * level[u];
-          }
-
-          // Modify epsilon
-          epsilon = 0;
-          for (int u = 0; u != _res_node_num; ++u) {
-            double curr, pu = pi[u];
-            int last_out = _first_out[u+1];
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              if (_res_cap[a] == 0) continue;
-              curr = _cost[a] + pu - pi[_target[a]];
-              if (-curr > epsilon) epsilon = -curr;
-            }
-          }
-        } else {
-          typedef HowardMmc<StaticDigraph, CostArcMap> HwMmc;
-          typedef HartmannOrlinMmc<StaticDigraph, CostArcMap> HoMmc;
-          typedef typename BellmanFord<StaticDigraph, CostArcMap>
-            ::template SetDistMap<CostNodeMap>::Create BF;
-
-          // Set epsilon to the minimum cycle mean
-          Cost cycle_cost = 0;
-          int cycle_size = 1;
-          buildResidualNetwork();
-          HwMmc hw_mmc(_sgr, _cost_map);
-          if (hw_mmc.findCycleMean(hw_iter_limit) == HwMmc::ITERATION_LIMIT) {
-            // Howard's algorithm reached the iteration limit, start a
-            // strongly polynomial algorithm instead
-            HoMmc ho_mmc(_sgr, _cost_map);
-            ho_mmc.findCycleMean();
-            epsilon = -ho_mmc.cycleMean();
-            cycle_cost = ho_mmc.cycleCost();
-            cycle_size = ho_mmc.cycleSize();
-          } else {
-            // Set epsilon
-            epsilon = -hw_mmc.cycleMean();
-            cycle_cost = hw_mmc.cycleCost();
-            cycle_size = hw_mmc.cycleSize();
-          }
-
-          // Compute feasible potentials for the current epsilon
-          for (int i = 0; i != int(_cost_vec.size()); ++i) {
-            _cost_vec[i] = cycle_size * _cost_vec[i] - cycle_cost;
-          }
-          BF bf(_sgr, _cost_map);
-          bf.distMap(_pi_map);
-          bf.init(0);
-          bf.start();
-          for (int u = 0; u != _res_node_num; ++u) {
-            pi[u] = static_cast<double>(_pi[u]) / cycle_size;
-          }
-
-          iter = limit;
-        }
-      }
-    }
-
-  }; //class CycleCanceling
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_CYCLE_CANCELING_H
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 1250)
+++ lemon/dfs.h	(revision 1125)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -48,5 +48,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -63,6 +63,5 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -83,6 +82,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -99,5 +97,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
@@ -123,9 +121,4 @@
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref DfsDefaultTraits
-  ///"DfsDefaultTraits<GR>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
@@ -153,5 +146,5 @@
     typedef PredMapPath<Digraph, PredMap> Path;
 
-    ///The \ref lemon::DfsDefaultTraits "traits class" of the algorithm.
+    ///The \ref DfsDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 
@@ -232,5 +225,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
@@ -252,5 +245,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
@@ -272,6 +265,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
@@ -293,5 +285,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
@@ -420,6 +412,6 @@
     ///The simplest way to execute the DFS algorithm is to use one of the
     ///member functions called \ref run(Node) "run()".\n
-    ///If you need better control on the execution, you have to call
-    ///\ref init() first, then you can add a source node with \ref addSource()
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), then you can add a source node with \ref addSource()
     ///and perform the actual computation with \ref start().
     ///This procedure can be repeated if there are nodes that have not
@@ -641,6 +633,10 @@
     ///Runs the algorithm to visit all nodes in the digraph.
 
-    ///This method runs the %DFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs the %DFS algorithm in order to compute the
+    ///%DFS path to each node.
+    ///
+    ///The algorithm computes
+    ///- the %DFS tree (forest),
+    ///- the distance of each node from the root(s) in the %DFS tree.
     ///
     ///\note <tt>d.run()</tt> is just a shortcut of the following code.
@@ -674,7 +670,7 @@
     ///@{
 
-    ///The DFS path to the given node.
-
-    ///Returns the DFS path to the given node from the root(s).
+    ///The DFS path to a node.
+
+    ///Returns the DFS path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -684,7 +680,7 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -695,5 +691,5 @@
     int dist(Node v) const { return (*_dist)[v]; }
 
-    ///Returns the 'previous arc' of the %DFS tree for the given node.
+    ///Returns the 'previous arc' of the %DFS tree for a node.
 
     ///This function returns the 'previous arc' of the %DFS tree for the
@@ -703,5 +699,5 @@
     ///
     ///The %DFS tree used here is equal to the %DFS tree used in
-    ///\ref predNode() and \ref predMap().
+    ///\ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -709,13 +705,13 @@
     Arc predArc(Node v) const { return (*_pred)[v];}
 
-    ///Returns the 'previous node' of the %DFS tree for the given node.
+    ///Returns the 'previous node' of the %DFS tree.
 
     ///This function returns the 'previous node' of the %DFS
     ///tree for the node \c v, i.e. it returns the last but one node
-    ///of a %DFS path from a root to \c v. It is \c INVALID
+    ///from a %DFS path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The %DFS tree used here is equal to the %DFS tree used in
-    ///\ref predArc() and \ref predMap().
+    ///\ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -738,5 +734,5 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the DFS tree (forest).
+    ///arcs, which form the DFS tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -744,5 +740,5 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node. node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -770,5 +766,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -785,6 +781,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
@@ -805,6 +801,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -821,5 +816,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
@@ -836,5 +831,5 @@
 
     ///The type of the DFS paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -842,6 +837,10 @@
   /// Default traits class used by DfsWizard
 
-  /// Default traits class used by DfsWizard.
-  /// \tparam GR The type of the digraph.
+  /// To make it easier to use Dfs algorithm
+  /// we have created a wizard class.
+  /// This \ref DfsWizard class needs default traits,
+  /// as well as the \ref Dfs class.
+  /// The \ref DfsWizardBase is a class to be the default traits of the
+  /// \ref DfsWizard class.
   template<class GR>
   class DfsWizardBase : public DfsWizardDefaultTraits<GR>
@@ -871,5 +870,5 @@
     /// Constructor.
 
-    /// This constructor does not require parameters, it initiates
+    /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to \c 0.
     DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -896,7 +895,4 @@
   /// This class should only be used through the \ref dfs() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class DfsWizard : public TR
@@ -904,4 +900,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -911,8 +908,14 @@
     typedef typename Digraph::OutArcIt OutArcIt;
 
+    ///\brief The type of the map that stores the predecessor
+    ///arcs of the DFS paths.
     typedef typename TR::PredMap PredMap;
+    ///\brief The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
+    ///\brief The type of the map that indicates which nodes are reached.
     typedef typename TR::ReachedMap ReachedMap;
+    ///\brief The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
+    ///The type of the DFS paths
     typedef typename TR::Path Path;
 
@@ -984,6 +987,6 @@
     ///Runs DFS algorithm to visit all nodes in the digraph.
 
-    ///This method runs DFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs DFS algorithm in order to compute
+    ///the DFS path to each node.
     void run()
     {
@@ -997,10 +1000,9 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the predecessor map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the predecessor arcs of the nodes.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     DfsWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1016,10 +1018,9 @@
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the reached map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are reached.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
     template<class T>
     DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
@@ -1035,11 +1036,9 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the distance map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the distances of the nodes calculated
-    ///by the algorithm.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     DfsWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1055,10 +1054,9 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-func-param "Named parameter" for setting
-    ///the processed map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are processed.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1212,6 +1210,5 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to the
-    /// \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1251,9 +1248,9 @@
   /// does not observe the DFS events. If you want to observe the DFS
   /// events, you should implement your own visitor class.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref DfsVisitDefaultTraits
-  /// "DfsVisitDefaultTraits<GR>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// \tparam TR Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
+  /// See \ref DfsVisitDefaultTraits for the documentation of
+  /// a DFS visit traits class.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
@@ -1374,6 +1371,6 @@
     /// The simplest way to execute the DFS algorithm is to use one of the
     /// member functions called \ref run(Node) "run()".\n
-    /// If you need better control on the execution, you have to call
-    /// \ref init() first, then you can add a source node with \ref addSource()
+    /// If you need more control on the execution, first you have to call
+    /// \ref init(), then you can add a source node with \ref addSource()
     /// and perform the actual computation with \ref start().
     /// This procedure can be repeated if there are nodes that have not
@@ -1588,6 +1585,10 @@
     /// \brief Runs the algorithm to visit all nodes in the digraph.
 
-    /// This method runs the %DFS algorithm in order to visit all nodes
-    /// in the digraph.
+    /// This method runs the %DFS algorithm in order to
+    /// compute the %DFS path to each node.
+    ///
+    /// The algorithm computes
+    /// - the %DFS tree (forest),
+    /// - the distance of each node from the root(s) in the %DFS tree.
     ///
     /// \note <tt>d.run()</tt> is just a shortcut of the following code.
@@ -1621,5 +1622,5 @@
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
+    /// \brief Checks if a node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).
Index: lemon/dheap.h
===================================================================
--- lemon/dheap.h	(revision 929)
+++ 	(revision )
@@ -1,352 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_DHEAP_H
-#define LEMON_DHEAP_H
-
-///\ingroup heaps
-///\file
-///\brief D-ary heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief D-ary heap data structure.
-  ///
-  /// This class implements the \e D-ary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The \ref DHeap "D-ary heap" is a generalization of the
-  /// \ref BinHeap "binary heap" structure, its nodes have at most
-  /// \c D children, instead of two.
-  /// \ref BinHeap and \ref QuadHeap are specialized implementations
-  /// of this structure for <tt>D=2</tt> and <tt>D=4</tt>, respectively.
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam D The degree of the heap, each node have at most \e D
-  /// children. The default is 16. Powers of two are suggested to use
-  /// so that the multiplications and divisions needed to traverse the
-  /// nodes of the heap could be performed faster.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-  ///
-  ///\sa BinHeap
-  ///\sa FouraryHeap
-#ifdef DOXYGEN
-  template <typename PR, typename IM, int D, typename CMP>
-#else
-  template <typename PR, typename IM, int D = 16,
-            typename CMP = std::less<PR> >
-#endif
-  class DHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit DHeap(ItemIntMap &map) : _iim(map) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    DHeap(ItemIntMap &map, const Compare &comp)
-      : _iim(map), _comp(comp) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() { _data.clear(); }
-
-  private:
-    int parent(int i) { return (i-1)/D; }
-    int firstChild(int i) { return D*i+1; }
-
-    bool less(const Pair &p1, const Pair &p2) const {
-      return _comp(p1.second, p2.second);
-    }
-
-    void bubbleUp(int hole, Pair p) {
-      int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
-        hole = par;
-        par = parent(hole);
-      }
-      move(p, hole);
-    }
-
-    void bubbleDown(int hole, Pair p, int length) {
-      if( length>1 ) {
-        int child = firstChild(hole);
-        while( child+D<=length ) {
-          int min=child;
-          for (int i=1; i<D; ++i) {
-            if( less(_data[child+i], _data[min]) )
-              min=child+i;
-          }
-          if( !less(_data[min], p) )
-            goto ok;
-          move(_data[min], hole);
-          hole = min;
-          child = firstChild(hole);
-        }
-        if ( child<length ) {
-          int min = child;
-          while (++child < length) {
-            if( less(_data[child], _data[min]) )
-              min=child;
-          }
-          if( less(_data[min], p) ) {
-            move(_data[min], hole);
-            hole = min;
-          }
-        }
-      }
-    ok:
-      move(p, hole);
-    }
-
-    void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
-    }
-
-  public:
-    /// \brief Insert a pair of item and priority into the heap.
-    ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
-    /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
-    void push(const Pair &p) {
-      int n = _data.size();
-      _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param i The item to insert.
-    /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[0].first; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[0].second; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
-      if (n>0) bubbleDown(0, _data[n], n);
-      _data.pop_back();
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
-    void erase(const Item &i) {
-      int h = _iim[i];
-      int n = _data.size()-1;
-      _iim.set(_data[h].first, POST_HEAP);
-      if( h<n ) {
-        if( less(_data[parent(h)], _data[n]) )
-          bubbleDown(h, _data[n], n);
-        else
-          bubbleUp(h, _data[n]);
-      }
-      _data.pop_back();
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].second;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param i The item.
-    /// \param p The priority.
-    void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      if( idx<0 )
-        push(i,p);
-      else if( _comp(p, _data[idx].second) )
-        bubbleUp(idx, Pair(i,p));
-      else
-        bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
-    void increase(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int s = _iim[i];
-      if (s>=0) s=0;
-      return State(s);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-        case POST_HEAP:
-        case PRE_HEAP:
-          if (state(i) == IN_HEAP) erase(i);
-          _iim[i] = st;
-          break;
-        case IN_HEAP:
-          break;
-      }
-    }
-
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
-    void replace(const Item& i, const Item& j) {
-      int idx=_iim[i];
-      _iim.set(i, _iim[j]);
-      _iim.set(j, idx);
-      _data[idx].first=j;
-    }
-
-  }; // class DHeap
-
-} // namespace lemon
-
-#endif // LEMON_DHEAP_H
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 1250)
+++ lemon/dijkstra.h	(revision 631)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,7 +71,7 @@
 
     ///The type of the map that stores the arc lengths.
-    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
-    ///The type of the arc lengths.
+    ///The type of the length of the arcs.
     typedef typename LEN::Value Value;
 
@@ -117,5 +117,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -132,6 +132,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -152,5 +152,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a \c DistMap.
@@ -169,8 +169,4 @@
   /// \ingroup shortest_path
   ///This class provides an efficient implementation of the %Dijkstra algorithm.
-  ///
-  ///The %Dijkstra algorithm solves the single-source shortest path problem
-  ///when all arc lengths are non-negative. If there are negative lengths,
-  ///the BellmanFord algorithm should be used instead.
   ///
   ///The arc lengths are passed to the algorithm using a
@@ -193,9 +189,4 @@
   ///it is necessary. The default map type is \ref
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref DijkstraDefaultTraits
-  ///"DijkstraDefaultTraits<GR, LEN>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename LEN, typename TR>
@@ -211,6 +202,6 @@
     typedef typename TR::Digraph Digraph;
 
-    ///The type of the arc lengths.
-    typedef typename TR::Value Value;
+    ///The type of the length of the arcs.
+    typedef typename TR::LengthMap::Value Value;
     ///The type of the map that stores the arc lengths.
     typedef typename TR::LengthMap LengthMap;
@@ -228,9 +219,9 @@
     ///The heap type used by the algorithm.
     typedef typename TR::Heap Heap;
-    /// \brief The \ref lemon::DijkstraDefaultOperationTraits
-    /// "operation traits class" of the algorithm.
+    ///\brief The \ref DijkstraDefaultOperationTraits "operation traits class"
+    ///of the algorithm.
     typedef typename TR::OperationTraits OperationTraits;
 
-    ///The \ref lemon::DijkstraDefaultTraits "traits class" of the algorithm.
+    ///The \ref DijkstraDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
 
@@ -314,5 +305,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap
@@ -335,5 +326,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap
@@ -356,5 +347,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap
@@ -432,5 +423,5 @@
     ///passed to the constructor of the cross reference and the cross
     ///reference should be passed to the constructor of the heap).
-    ///However, external heap and cross reference objects could also be
+    ///However external heap and cross reference objects could also be
     ///passed to the algorithm using the \ref heap() function before
     ///calling \ref run(Node) "run()" or \ref init().
@@ -453,5 +444,4 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c OperationTraits type.
-    /// For more information, see \ref DijkstraDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
@@ -595,6 +585,6 @@
     ///The simplest way to execute the %Dijkstra algorithm is to use
     ///one of the member functions called \ref run(Node) "run()".\n
-    ///If you need better control on the execution, you have to call
-    ///\ref init() first, then you can add several source nodes with
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), then you can add several source nodes with
     ///\ref addSource(). Finally the actual path computation can be
     ///performed with one of the \ref start() functions.
@@ -812,12 +802,12 @@
     ///The results of the %Dijkstra algorithm can be obtained using these
     ///functions.\n
-    ///Either \ref run(Node) "run()" or \ref init() should be called
+    ///Either \ref run(Node) "run()" or \ref start() should be called
     ///before using them.
 
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns the shortest path to the given node from the root(s).
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -827,7 +817,7 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -838,7 +828,6 @@
     Value dist(Node v) const { return (*_dist)[v]; }
 
-    ///\brief Returns the 'previous arc' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous arc' of the shortest path tree for a node.
+
     ///This function returns the 'previous arc' of the shortest path
     ///tree for the node \c v, i.e. it returns the last arc of a
@@ -847,5 +836,5 @@
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predNode() and \ref predMap().
+    ///tree used in \ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -853,14 +842,13 @@
     Arc predArc(Node v) const { return (*_pred)[v]; }
 
-    ///\brief Returns the 'previous node' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous node' of the shortest path tree for a node.
+
     ///This function returns the 'previous node' of the shortest path
     ///tree for the node \c v, i.e. it returns the last but one node
-    ///of a shortest path from a root to \c v. It is \c INVALID
+    ///from a shortest path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predArc() and \ref predMap().
+    ///tree used in \ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -883,5 +871,5 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
+    ///arcs, which form the shortest path tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -889,5 +877,5 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -908,7 +896,7 @@
                                           Heap::POST_HEAP; }
 
-    ///The current distance of the given node from the root(s).
-
-    ///Returns the current distance of the given node from the root(s).
+    ///The current distance of a node from the root(s).
+
+    ///Returns the current distance of a node from the root(s).
     ///It may be decreased in the following processes.
     ///
@@ -937,7 +925,7 @@
 
     ///The type of the map that stores the arc lengths.
-    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
-    ///The type of the arc lengths.
+    ///The type of the length of the arcs.
     typedef typename LEN::Value Value;
 
@@ -986,5 +974,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -1001,6 +989,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
@@ -1021,5 +1009,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a DistMap.
@@ -1036,5 +1024,5 @@
 
     ///The type of the shortest paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -1042,7 +1030,10 @@
   /// Default traits class used by DijkstraWizard
 
-  /// Default traits class used by DijkstraWizard.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
+  /// To make it easier to use Dijkstra algorithm
+  /// we have created a wizard class.
+  /// This \ref DijkstraWizard class needs default traits,
+  /// as well as the \ref Dijkstra class.
+  /// The \ref DijkstraWizardBase is a class to be the default traits of the
+  /// \ref DijkstraWizard class.
   template<typename GR, typename LEN>
   class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
@@ -1098,7 +1089,4 @@
   /// This class should only be used through the \ref dijkstra() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class DijkstraWizard : public TR
@@ -1106,4 +1094,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -1113,10 +1102,18 @@
     typedef typename Digraph::OutArcIt OutArcIt;
 
+    ///The type of the map that stores the arc lengths.
     typedef typename TR::LengthMap LengthMap;
+    ///The type of the length of the arcs.
     typedef typename LengthMap::Value Value;
+    ///\brief The type of the map that stores the predecessor
+    ///arcs of the shortest paths.
     typedef typename TR::PredMap PredMap;
+    ///The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
+    ///The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
+    ///The type of the shortest paths
     typedef typename TR::Path Path;
+    ///The heap type used by the dijkstra algorithm.
     typedef typename TR::Heap Heap;
 
@@ -1190,10 +1187,9 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the predecessor map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the predecessor arcs of the nodes.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1209,11 +1205,9 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the distance map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the distances of the nodes calculated
-    ///by the algorithm.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1229,10 +1223,9 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-func-param "Named parameter" for setting
-    ///the processed map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are processed.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1247,5 +1240,4 @@
       SetPathBase(const TR &b) : TR(b) {}
     };
-
     ///\brief \ref named-func-param "Named parameter"
     ///for getting the shortest path to the target node.
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 761)
+++ lemon/dim2.h	(revision 463)
@@ -22,7 +22,14 @@
 #include <iostream>
 
-///\ingroup geomdat
+///\ingroup misc
 ///\file
 ///\brief A simple two dimensional vector and a bounding box implementation
+///
+/// The class \ref lemon::dim2::Point "dim2::Point" implements
+/// a two dimensional vector with the usual operations.
+///
+/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine
+/// the rectangular bounding box of a set of
+/// \ref lemon::dim2::Point "dim2::Point"'s.
 
 namespace lemon {
@@ -34,5 +41,5 @@
   namespace dim2 {
 
-  /// \addtogroup geomdat
+  /// \addtogroup misc
   /// @{
 
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 956)
+++ lemon/dimacs.h	(revision 631)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -62,5 +62,5 @@
 
   ///This function starts seeking the beginning of the given file for the
-  ///problem type and size info.
+  ///problem type and size info. 
   ///The found data is returned in a special struct that can be evaluated
   ///and passed to the appropriate reader function.
@@ -213,5 +213,5 @@
         std::numeric_limits<Capacity>::infinity() :
         std::numeric_limits<Capacity>::max();
-
+ 
     while (is >> c) {
       switch (c) {
@@ -238,5 +238,5 @@
           e = g.addArc(nodes[i], nodes[j]);
           capacity.set(e, _cap);
-        }
+        } 
         else if (desc.type==DimacsDescriptor::MAX) {
           is >> i >> j >> _cap;
@@ -363,9 +363,9 @@
     g.addArc(s,t);
   }
-
+  
   /// \brief DIMACS plain (di)graph reader function.
   ///
   /// This function reads a plain (di)graph without any designated nodes
-  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
+  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
   /// DIMACS files having a line starting with
   /// \code
@@ -393,5 +393,5 @@
       nodes[k] = g.addNode();
     }
-
+    
     while (is >> c) {
       switch (c) {
Index: lemon/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 956)
+++ lemon/edge_set.h	(revision 717)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -256,12 +256,11 @@
   /// all arcs incident to the given node is erased from the arc set.
   ///
-  /// This class fully conforms to the \ref concepts::Digraph
-  /// "Digraph" concept.
-  /// It provides only linear time counting for nodes and arcs.
-  ///
   /// \param GR The type of the graph which shares its node set with
   /// this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
   /// concept.
+  ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph" concept.
   template <typename GR>
   class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
@@ -687,11 +686,10 @@
   /// incident to the given node is erased from the arc set.
   ///
-  /// This class fully conforms to the \ref concepts::Graph "Graph"
-  /// concept.
-  /// It provides only linear time counting for nodes, edges and arcs.
-  ///
   /// \param GR The type of the graph which shares its node set
   /// with this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
+  /// concept.
+  ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph"
   /// concept.
   template <typename GR>
@@ -870,5 +868,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc.id;
     }
@@ -957,12 +955,11 @@
   /// arcs. Therefore the arcs cannot be erased from the arc sets.
   ///
-  /// This class fully conforms to the \ref concepts::Digraph "Digraph"
-  /// concept.
-  /// It provides only linear time counting for nodes and arcs.
-  ///
   /// \warning If a node is erased from the underlying graph and this
   /// node is the source or target of one arc in the arc set, then
   /// the arc set is invalidated, and it cannot be used anymore. The
   /// validity can be checked with the \c valid() member function.
+  ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph" concept.
   template <typename GR>
   class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
@@ -1177,5 +1174,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc.id;
     }
@@ -1185,5 +1182,5 @@
     }
 
-    static void next(Edge& arc) {
+    void next(Edge& arc) const {
       --arc.id;
     }
@@ -1308,12 +1305,11 @@
   /// edges cannot be erased from the edge sets.
   ///
-  /// This class fully conforms to the \ref concepts::Graph "Graph"
-  /// concept.
-  /// It provides only linear time counting for nodes, edges and arcs.
-  ///
   /// \warning If a node is erased from the underlying graph and this
   /// node is incident to one edge in the edge set, then the edge set
   /// is invalidated, and it cannot be used anymore. The validity can
   /// be checked with the \c valid() member function.
+  ///
+  /// This class fully conforms to the \ref concepts::Graph
+  /// "Graph" concept.
   template <typename GR>
   class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {
Index: lemon/edmonds_karp.h
===================================================================
--- lemon/edmonds_karp.h	(revision 1250)
+++ 	(revision )
@@ -1,556 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_EDMONDS_KARP_H
-#define LEMON_EDMONDS_KARP_H
-
-/// \file
-/// \ingroup max_flow
-/// \brief Implementation of the Edmonds-Karp algorithm.
-
-#include <lemon/tolerance.h>
-#include <vector>
-
-namespace lemon {
-
-  /// \brief Default traits class of EdmondsKarp class.
-  ///
-  /// Default traits class of EdmondsKarp class.
-  /// \param GR Digraph type.
-  /// \param CAP Type of capacity map.
-  template <typename GR, typename CAP>
-  struct EdmondsKarpDefaultTraits {
-
-    /// \brief The digraph type the algorithm runs on. 
-    typedef GR Digraph;
-
-    /// \brief The type of the map that stores the arc capacities.
-    ///
-    /// The type of the map that stores the arc capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CAP CapacityMap;
-
-    /// \brief The type of the flow values.
-    typedef typename CapacityMap::Value Value;
-
-    /// \brief The type of the map that stores the flow values.
-    ///
-    /// The type of the map that stores the flow values.
-    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-#ifdef DOXYGEN
-    typedef GR::ArcMap<Value> FlowMap;
-#else
-    typedef typename Digraph::template ArcMap<Value> FlowMap;
-#endif
-
-    /// \brief Instantiates a FlowMap.
-    ///
-    /// This function instantiates a \ref FlowMap. 
-    /// \param digraph The digraph for which we would like to define
-    /// the flow map.
-    static FlowMap* createFlowMap(const Digraph& digraph) {
-      return new FlowMap(digraph);
-    }
-
-    /// \brief The tolerance used by the algorithm
-    ///
-    /// The tolerance used by the algorithm to handle inexact computation.
-    typedef lemon::Tolerance<Value> Tolerance;
-
-  };
-
-  /// \ingroup max_flow
-  ///
-  /// \brief Edmonds-Karp algorithms class.
-  ///
-  /// This class provides an implementation of the \e Edmonds-Karp \e
-  /// algorithm producing a \ref max_flow "flow of maximum value" in a
-  /// digraph \cite clrs01algorithms, \cite amo93networkflows,
-  /// \cite edmondskarp72theoretical.
-  /// The Edmonds-Karp algorithm is slower than the Preflow
-  /// algorithm, but it has an advantage of the step-by-step execution
-  /// control with feasible flow solutions. The \e source node, the \e
-  /// target node, the \e capacity of the arcs and the \e starting \e
-  /// flow value of the arcs should be passed to the algorithm
-  /// through the constructor.
-  ///
-  /// The time complexity of the algorithm is \f$ O(nm^2) \f$ in
-  /// worst case. Always try the Preflow algorithm instead of this if
-  /// you just want to compute the optimal flow.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CAP The type of the capacity map. The default map
-  /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>". 
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref EdmondsKarpDefaultTraits
-  /// "EdmondsKarpDefaultTraits<GR, CAP>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-
-#ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TR>
-#else 
-  template <typename GR,
-	    typename CAP = typename GR::template ArcMap<int>,
-            typename TR = EdmondsKarpDefaultTraits<GR, CAP> >
-#endif
-  class EdmondsKarp {
-  public:
-
-    /// \brief The \ref lemon::EdmondsKarpDefaultTraits "traits class"
-    /// of the algorithm.
-    typedef TR Traits;
-    /// The type of the digraph the algorithm runs on.
-    typedef typename Traits::Digraph Digraph;
-    /// The type of the capacity map.
-    typedef typename Traits::CapacityMap CapacityMap;
-    /// The type of the flow values.
-    typedef typename Traits::Value Value; 
-
-    /// The type of the flow map.
-    typedef typename Traits::FlowMap FlowMap;
-    /// The type of the tolerance.
-    typedef typename Traits::Tolerance Tolerance;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-    typedef typename Digraph::template NodeMap<Arc> PredMap;
-    
-    const Digraph& _graph;
-    const CapacityMap* _capacity;
-
-    Node _source, _target;
-
-    FlowMap* _flow;
-    bool _local_flow;
-
-    PredMap* _pred;
-    std::vector<Node> _queue;
-    
-    Tolerance _tolerance;
-    Value _flow_value;
-
-    void createStructures() {
-      if (!_flow) {
-	_flow = Traits::createFlowMap(_graph);
-	_local_flow = true;
-      }
-      if (!_pred) {
-	_pred = new PredMap(_graph);
-      }
-      _queue.resize(countNodes(_graph));
-    }
-
-    void destroyStructures() {
-      if (_local_flow) {
-	delete _flow;
-      }
-      if (_pred) {
-	delete _pred;
-      }
-    }
-    
-  public:
-
-    typedef EdmondsKarp Create;
-
-    ///\name Named template parameters
-
-    ///@{
-
-    template <typename T>
-    struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
-      static FlowMap *createFlowMap(const Digraph&) {
-	LEMON_ASSERT(false, "FlowMap is not initialized");
-        return 0;
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// FlowMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting FlowMap
-    /// type
-    template <typename T>
-    struct SetFlowMap 
-      : public EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > {
-      typedef EdmondsKarp<Digraph, CapacityMap, SetFlowMapTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-    
-    EdmondsKarp() {}
-
-  public:
-
-    /// \brief The constructor of the class.
-    ///
-    /// The constructor of the class. 
-    /// \param digraph The digraph the algorithm runs on. 
-    /// \param capacity The capacity of the arcs. 
-    /// \param source The source node.
-    /// \param target The target node.
-    EdmondsKarp(const Digraph& digraph, const CapacityMap& capacity,
-		Node source, Node target)
-      : _graph(digraph), _capacity(&capacity), _source(source), _target(target),
-	_flow(0), _local_flow(false), _pred(0), _tolerance(), _flow_value()
-    {
-      LEMON_ASSERT(_source != _target,
-                   "Flow source and target are the same nodes.");
-    }
-
-    /// \brief Destructor.
-    ///
-    /// Destructor.
-    ~EdmondsKarp() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the capacity map.
-    ///
-    /// Sets the capacity map.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& capacityMap(const CapacityMap& map) {
-      _capacity = &map;
-      return *this;
-    }
-
-    /// \brief Sets the flow map.
-    ///
-    /// Sets the flow map.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& flowMap(FlowMap& map) {
-      if (_local_flow) {
-	delete _flow;
-	_local_flow = false;
-      }
-      _flow = &map;
-      return *this;
-    }
-
-    /// \brief Sets the source node.
-    ///
-    /// Sets the source node.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& source(const Node& node) {
-      _source = node;
-      return *this;
-    }
-
-    /// \brief Sets the target node.
-    ///
-    /// Sets the target node.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& target(const Node& node) {
-      _target = node;
-      return *this;
-    }
-
-    /// \brief Sets the tolerance used by algorithm.
-    ///
-    /// Sets the tolerance used by algorithm.
-    /// \return <tt>(*this)</tt>
-    EdmondsKarp& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    } 
-
-    /// \brief Returns a const reference to the tolerance.
-    ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    } 
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use \ref run().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
-    /// \ref start() or multiple times the \ref augment() function.
-    
-    ///@{
-
-    /// \brief Initializes the algorithm.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to zero on each arc.
-    void init() {
-      createStructures();
-      for (ArcIt it(_graph); it != INVALID; ++it) {
-        _flow->set(it, 0);
-      }
-      _flow_value = 0;
-    }
-    
-    /// \brief Initializes the algorithm using the given flow map.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to the given \c flowMap. The \c flowMap should
-    /// contain a feasible flow, i.e. at each node excluding the source
-    /// and the target, the incoming flow should be equal to the
-    /// outgoing flow.
-    template <typename FlowMap>
-    void init(const FlowMap& flowMap) {
-      createStructures();
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-	_flow->set(e, flowMap[e]);
-      }
-      _flow_value = 0;
-      for (OutArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value += (*_flow)[jt];
-      }
-      for (InArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value -= (*_flow)[jt];
-      }
-    }
-
-    /// \brief Initializes the algorithm using the given flow map.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// flow to the given \c flowMap. The \c flowMap should
-    /// contain a feasible flow, i.e. at each node excluding the source
-    /// and the target, the incoming flow should be equal to the
-    /// outgoing flow. 
-    /// \return \c false when the given \c flowMap does not contain a
-    /// feasible flow.
-    template <typename FlowMap>
-    bool checkedInit(const FlowMap& flowMap) {
-      createStructures();
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-	_flow->set(e, flowMap[e]);
-      }
-      for (NodeIt it(_graph); it != INVALID; ++it) {
-        if (it == _source || it == _target) continue;
-        Value outFlow = 0;
-        for (OutArcIt jt(_graph, it); jt != INVALID; ++jt) {
-          outFlow += (*_flow)[jt];
-        }
-        Value inFlow = 0;
-        for (InArcIt jt(_graph, it); jt != INVALID; ++jt) {
-          inFlow += (*_flow)[jt];
-        }
-        if (_tolerance.different(outFlow, inFlow)) {
-          return false;
-        }
-      }
-      for (ArcIt it(_graph); it != INVALID; ++it) {
-        if (_tolerance.less((*_flow)[it], 0)) return false;
-        if (_tolerance.less((*_capacity)[it], (*_flow)[it])) return false;
-      }
-      _flow_value = 0;
-      for (OutArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value += (*_flow)[jt];
-      }
-      for (InArcIt jt(_graph, _source); jt != INVALID; ++jt) {
-        _flow_value -= (*_flow)[jt];
-      }
-      return true;
-    }
-
-    /// \brief Augments the solution along a shortest path.
-    /// 
-    /// Augments the solution along a shortest path. This function searches a
-    /// shortest path between the source and the target
-    /// in the residual digraph by the Bfs algoritm.
-    /// Then it increases the flow on this path with the minimal residual
-    /// capacity on the path. If there is no such path, it gives back
-    /// false.
-    /// \return \c false when the augmenting did not success, i.e. the
-    /// current flow is a feasible and optimal solution.
-    bool augment() {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-	_pred->set(n, INVALID);
-      }
-      
-      int first = 0, last = 1;
-      
-      _queue[0] = _source;
-      _pred->set(_source, OutArcIt(_graph, _source));
-
-      while (first != last && (*_pred)[_target] == INVALID) {
-	Node n = _queue[first++];
-	
-	for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-	  Value rem = (*_capacity)[e] - (*_flow)[e];
-	  Node t = _graph.target(e);
-	  if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
-	    _pred->set(t, e);
-	    _queue[last++] = t;
-	  }
-	}
-	for (InArcIt e(_graph, n); e != INVALID; ++e) {
-	  Value rem = (*_flow)[e];
-	  Node t = _graph.source(e);
-	  if (_tolerance.positive(rem) && (*_pred)[t] == INVALID) {
-	    _pred->set(t, e);
-	    _queue[last++] = t;
-	  }
-	}
-      }
-
-      if ((*_pred)[_target] != INVALID) {
-	Node n = _target;
-	Arc e = (*_pred)[n];
-
-	Value prem = (*_capacity)[e] - (*_flow)[e];
-	n = _graph.source(e);
-	while (n != _source) {
-	  e = (*_pred)[n];
-	  if (_graph.target(e) == n) {
-	    Value rem = (*_capacity)[e] - (*_flow)[e];
-	    if (rem < prem) prem = rem;
-	    n = _graph.source(e);
-	  } else {
-	    Value rem = (*_flow)[e];
-	    if (rem < prem) prem = rem;
-	    n = _graph.target(e);   
-	  } 
-	}
-
-	n = _target;
-	e = (*_pred)[n];
-
-	_flow->set(e, (*_flow)[e] + prem);
-	n = _graph.source(e);
-	while (n != _source) {
-	  e = (*_pred)[n];
-	  if (_graph.target(e) == n) {
-	    _flow->set(e, (*_flow)[e] + prem);
-	    n = _graph.source(e);
-	  } else {
-	    _flow->set(e, (*_flow)[e] - prem);
-	    n = _graph.target(e);   
-	  } 
-	}
-
-	_flow_value += prem;	
-	return true;
-      } else {
-	return false;
-      }
-    }
-
-    /// \brief Executes the algorithm
-    ///
-    /// Executes the algorithm by performing augmenting phases until the
-    /// optimal solution is reached. 
-    /// \pre One of the \ref init() functions must be called before
-    /// using this function.
-    void start() {
-      while (augment()) {}
-    }
-
-    /// \brief Runs the algorithm.
-    /// 
-    /// Runs the Edmonds-Karp algorithm.
-    /// \note ek.run() is just a shortcut of the following code.
-    ///\code 
-    /// ek.init();
-    /// ek.start();
-    ///\endcode
-    void run() {
-      init();
-      start();
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The result of the Edmonds-Karp algorithm can be obtained using these
-    /// functions.\n
-    /// Either \ref run() or \ref start() should be called before using them.
-    
-    ///@{
-
-    /// \brief Returns the value of the maximum flow.
-    ///
-    /// Returns the value of the maximum flow found by the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value flowValue() const {
-      return _flow_value;
-    }
-
-    /// \brief Returns the flow value on the given arc.
-    ///
-    /// Returns the flow value on the given arc.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value flow(const Arc& arc) const {
-      return (*_flow)[arc];
-    }
-
-    /// \brief Returns a const reference to the flow map.
-    ///
-    /// Returns a const reference to the arc map storing the found flow.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const FlowMap& flowMap() const {
-      return *_flow;
-    }
-
-    /// \brief Returns \c true when the node is on the source side of the
-    /// minimum cut.
-    ///
-    /// Returns true when the node is on the source side of the found
-    /// minimum cut.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    bool minCut(const Node& node) const {
-      return ((*_pred)[node] != INVALID) || node == _source;
-    }
-
-    /// \brief Gives back a minimum value cut.
-    ///
-    /// Sets \c cutMap to the characteristic vector of a minimum value
-    /// cut. \c cutMap should be a \ref concepts::WriteMap "writable"
-    /// node map with \c bool (or convertible) value type.
-    ///
-    /// \note This function calls \ref minCut() for each node, so it runs in
-    /// O(n) time.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    template <typename CutMap>
-    void minCutMap(CutMap& cutMap) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-	cutMap.set(n, (*_pred)[n] != INVALID);
-      }
-      cutMap.set(_source, true);
-    }    
-
-    /// @}
-
-  };
-
-}
-
-#endif
Index: lemon/euler.h
===================================================================
--- lemon/euler.h	(revision 1023)
+++ lemon/euler.h	(revision 695)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,5 @@
 /// \ingroup graph_properties
 /// \file
-/// \brief Euler tour iterators and a function for checking the \e Eulerian
+/// \brief Euler tour iterators and a function for checking the \e Eulerian 
 /// property.
 ///
@@ -37,10 +37,10 @@
   ///Euler tour iterator for digraphs.
 
-  /// \ingroup graph_properties
+  /// \ingroup graph_prop
   ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
   ///graph (if there exists) and it converts to the \c Arc type of the digraph.
   ///
   ///For example, if the given digraph has an Euler tour (i.e it has only one
-  ///non-trivial component and the in-degree is equal to the out-degree
+  ///non-trivial component and the in-degree is equal to the out-degree 
   ///for all nodes), then the following code will put the arcs of \c g
   ///to the vector \c et according to an Euler tour of \c g.
@@ -139,5 +139,5 @@
   ///and \c Edge types of the graph.
   ///
-  ///For example, if the given graph has an Euler tour (i.e it has only one
+  ///For example, if the given graph has an Euler tour (i.e it has only one 
   ///non-trivial component and the degree of each node is even),
   ///the following code will print the arc IDs according to an
@@ -148,5 +148,5 @@
   ///  }
   ///\endcode
-  ///Although this iterator is for undirected graphs, it still returns
+  ///Although this iterator is for undirected graphs, it still returns 
   ///arcs in order to indicate the direction of the tour.
   ///(But arcs convert to edges, of course.)
@@ -234,5 +234,5 @@
     /// Postfix incrementation.
     ///
-    ///\warning This incrementation returns an \c Arc (which converts to
+    ///\warning This incrementation returns an \c Arc (which converts to 
     ///an \c Edge), not an \ref EulerIt, as one may expect.
     Arc operator++(int)
Index: lemon/fib_heap.h
===================================================================
--- lemon/fib_heap.h	(revision 758)
+++ lemon/fib_heap.h	(revision 730)
@@ -21,9 +21,8 @@
 
 ///\file
-///\ingroup heaps
-///\brief Fibonacci heap implementation.
+///\ingroup auxdat
+///\brief Fibonacci Heap implementation.
 
 #include <vector>
-#include <utility>
 #include <functional>
 #include <lemon/math.h>
@@ -31,37 +30,42 @@
 namespace lemon {
 
-  /// \ingroup heaps
+  /// \ingroup auxdat
   ///
-  /// \brief Fibonacci heap data structure.
+  ///\brief Fibonacci Heap.
   ///
-  /// This class implements the \e Fibonacci \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///This class implements the \e Fibonacci \e heap data structure. A \e heap
+  ///is a data structure for storing items with specified values called \e
+  ///priorities in such a way that finding the item with minimum priority is
+  ///efficient. \c CMP specifies the ordering of the priorities. In a heap
+  ///one can change the priority of an item, add or erase an item, etc.
   ///
-  /// The methods \ref increase() and \ref erase() are not efficient in a
-  /// Fibonacci heap. In case of many calls of these operations, it is
-  /// better to use other heap structure, e.g. \ref BinHeap "binary heap".
+  ///The methods \ref increase and \ref erase are not efficient in a Fibonacci
+  ///heap. In case of many calls to these operations, it is better to use a
+  ///\ref BinHeap "binary heap".
   ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
+  ///\param PRIO Type of the priority of the items.
+  ///\param IM A read and writable Item int map, used internally
+  ///to handle the cross references.
+  ///\param CMP A class for the ordering of the priorities. The
+  ///default is \c std::less<PRIO>.
+  ///
+  ///\sa BinHeap
+  ///\sa Dijkstra
 #ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
+  template <typename PRIO, typename IM, typename CMP>
 #else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
+  template <typename PRIO, typename IM, typename CMP = std::less<PRIO> >
 #endif
   class FibHeap {
   public:
-
-    /// Type of the item-int map.
+    ///\e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
+    ///\e
+    typedef PRIO Prio;
+    ///\e
     typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
+    ///\e
     typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
+    ///\e
     typedef CMP Compare;
 
@@ -77,8 +81,8 @@
   public:
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -91,20 +95,16 @@
     };
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor
+    ///
+    /// \c map should be given to the constructor, since it is
+    ///   used internally to handle the cross references.
     explicit FibHeap(ItemIntMap &map)
       : _minimum(0), _iim(map), _num() {}
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
+    /// \brief The constructor
+    ///
+    /// \c map should be given to the constructor, since it is used
+    /// internally to handle the cross references. \c comp is an
+    /// object for ordering of the priorities.
     FibHeap(ItemIntMap &map, const Compare &comp)
       : _minimum(0), _iim(map), _comp(comp), _num() {}
@@ -112,31 +112,41 @@
     /// \brief The number of items stored in the heap.
     ///
-    /// This function returns the number of items stored in the heap.
+    /// Returns the number of items stored in the heap.
     int size() const { return _num; }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    ///   Returns \c true if and only if the heap stores no items.
     bool empty() const { return _num==0; }
 
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference
+    /// map.  If you want to reuse a heap what is not surely empty you
+    /// should first clear the heap and after that you should set the
+    /// cross reference map for each item to \c PRE_HEAP.
     void clear() {
       _data.clear(); _minimum = 0; _num = 0;
     }
 
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param item The item to insert.
-    /// \param prio The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& prio) {
+    /// \brief \c item gets to the heap with priority \c value independently
+    /// if \c item was already there.
+    ///
+    /// This method calls \ref push(\c item, \c value) if \c item is not
+    /// stored in the heap and it calls \ref decrease(\c item, \c value) or
+    /// \ref increase(\c item, \c value) otherwise.
+    void set (const Item& item, const Prio& value) {
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        if ( _comp(value, _data[i].prio) ) decrease(item, value);
+        if ( _comp(_data[i].prio, value) ) increase(item, value);
+      } else push(item, value);
+    }
+
+    /// \brief Adds \c item to the heap with priority \c value.
+    ///
+    /// Adds \c item to the heap with priority \c value.
+    /// \pre \c item must not be stored in the heap.
+    void push (const Item& item, const Prio& value) {
       int i=_iim[item];
       if ( i < 0 ) {
@@ -159,28 +169,38 @@
         _data[_minimum].right_neighbor=i;
         _data[i].left_neighbor=_minimum;
-        if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
+        if ( _comp( value, _data[_minimum].prio) ) _minimum=i;
       } else {
         _data[i].right_neighbor=_data[i].left_neighbor=i;
         _minimum=i;
       }
-      _data[i].prio=prio;
+      _data[i].prio=value;
       ++_num;
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority relative to \c Compare.
+    ///
+    /// This method returns the item with minimum priority relative to \c
+    /// Compare.
+    /// \pre The heap must be nonempty.
     Item top() const { return _data[_minimum].name; }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[_minimum].prio; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Returns the minimum priority relative to \c Compare.
+    ///
+    /// It returns the minimum priority relative to \c Compare.
+    /// \pre The heap must be nonempty.
+    const Prio& prio() const { return _data[_minimum].prio; }
+
+    /// \brief Returns the priority of \c item.
+    ///
+    /// It returns the priority of \c item.
+    /// \pre \c item must be in the heap.
+    const Prio& operator[](const Item& item) const {
+      return _data[_iim[item]].prio;
+    }
+
+    /// \brief Deletes the item with minimum priority relative to \c Compare.
+    ///
+    /// This method deletes the item with minimum priority relative to \c
+    /// Compare from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -189,5 +209,5 @@
         _data[_minimum].in=false;
         if ( _data[_minimum].degree!=0 ) {
-          makeRoot(_data[_minimum].child);
+          makeroot(_data[_minimum].child);
           _minimum=_data[_minimum].child;
           balance();
@@ -202,5 +222,5 @@
           int last_child=_data[child].left_neighbor;
 
-          makeRoot(child);
+          makeroot(child);
 
           _data[left].right_neighbor=child;
@@ -215,10 +235,8 @@
     }
 
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param item The item to delete.
-    /// \pre \e item must be in the heap.
+    /// \brief Deletes \c item from the heap.
+    ///
+    /// This method deletes \c item from the heap, if \c item was already
+    /// stored in the heap. It is quite inefficient in Fibonacci heaps.
     void erase (const Item& item) {
       int i=_iim[item];
@@ -235,66 +253,41 @@
     }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    Prio operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param item The item.
-    /// \param prio The priority.
-    void set (const Item& item, const Prio& prio) {
+    /// \brief Decreases the priority of \c item to \c value.
+    ///
+    /// This method decreases the priority of \c item to \c value.
+    /// \pre \c item must be stored in the heap with priority at least \c
+    ///   value relative to \c Compare.
+    void decrease (Item item, const Prio& value) {
       int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        if ( _comp(prio, _data[i].prio) ) decrease(item, prio);
-        if ( _comp(_data[i].prio, prio) ) increase(item, prio);
-      } else push(item, prio);
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param prio The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e prio.
-    void decrease (const Item& item, const Prio& prio) {
-      int i=_iim[item];
-      _data[i].prio=prio;
+      _data[i].prio=value;
       int p=_data[i].parent;
 
-      if ( p!=-1 && _comp(prio, _data[p].prio) ) {
+      if ( p!=-1 && _comp(value, _data[p].prio) ) {
         cut(i,p);
         cascade(p);
       }
-      if ( _comp(prio, _data[_minimum].prio) ) _minimum=i;
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param prio The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e prio.
-    void increase (const Item& item, const Prio& prio) {
+      if ( _comp(value, _data[_minimum].prio) ) _minimum=i;
+    }
+
+    /// \brief Increases the priority of \c item to \c value.
+    ///
+    /// This method sets the priority of \c item to \c value. Though
+    /// there is no precondition on the priority of \c item, this
+    /// method should be used only if it is indeed necessary to increase
+    /// (relative to \c Compare) the priority of \c item, because this
+    /// method is inefficient.
+    void increase (Item item, const Prio& value) {
       erase(item);
-      push(item, prio);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param item The item.
+      push(item, value);
+    }
+
+
+    /// \brief Returns if \c item is in, has already been in, or has never
+    /// been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     State state(const Item &item) const {
       int i=_iim[item];
@@ -306,9 +299,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time _complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -373,5 +366,5 @@
     }
 
-    void makeRoot(int c) {
+    void makeroot(int c) {
       int s=c;
       do {
Index: lemon/fractional_matching.h
===================================================================
--- lemon/fractional_matching.h	(revision 1250)
+++ 	(revision )
@@ -1,2139 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_FRACTIONAL_MATCHING_H
-#define LEMON_FRACTIONAL_MATCHING_H
-
-#include <vector>
-#include <queue>
-#include <set>
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/unionfind.h>
-#include <lemon/bin_heap.h>
-#include <lemon/maps.h>
-#include <lemon/assert.h>
-#include <lemon/elevator.h>
-
-///\ingroup matching
-///\file
-///\brief Fractional matching algorithms in general graphs.
-
-namespace lemon {
-
-  /// \brief Default traits class of MaxFractionalMatching class.
-  ///
-  /// Default traits class of MaxFractionalMatching class.
-  /// \tparam GR Graph type.
-  template <typename GR>
-  struct MaxFractionalMatchingDefaultTraits {
-
-    /// \brief The type of the graph the algorithm runs on.
-    typedef GR Graph;
-
-    /// \brief The type of the map that stores the matching.
-    ///
-    /// The type of the map that stores the matching arcs.
-    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-    typedef typename Graph::template NodeMap<typename GR::Arc> MatchingMap;
-
-    /// \brief Instantiates a MatchingMap.
-    ///
-    /// This function instantiates a \ref MatchingMap.
-    /// \param graph The graph for which we would like to define
-    /// the matching map.
-    static MatchingMap* createMatchingMap(const Graph& graph) {
-      return new MatchingMap(graph);
-    }
-
-    /// \brief The elevator type used by MaxFractionalMatching algorithm.
-    ///
-    /// The elevator type used by MaxFractionalMatching algorithm.
-    ///
-    /// \sa Elevator
-    /// \sa LinkedElevator
-    typedef LinkedElevator<Graph, typename Graph::Node> Elevator;
-
-    /// \brief Instantiates an Elevator.
-    ///
-    /// This function instantiates an \ref Elevator.
-    /// \param graph The graph for which we would like to define
-    /// the elevator.
-    /// \param max_level The maximum level of the elevator.
-    static Elevator* createElevator(const Graph& graph, int max_level) {
-      return new Elevator(graph, max_level);
-    }
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Max cardinality fractional matching
-  ///
-  /// This class provides an implementation of fractional matching
-  /// algorithm based on push-relabel principle.
-  ///
-  /// The maximum cardinality fractional matching is a relaxation of the
-  /// maximum cardinality matching problem where the odd set constraints
-  /// are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result can be represented as the union of a
-  /// matching with one value edges and a set of odd length cycles
-  /// with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// barrier. The number of adjacents of any node set minus the size
-  /// of node set is a lower bound on the uncovered nodes in the
-  /// graph. For maximum matching a barrier is computed which
-  /// maximizes this difference.
-  ///
-  /// The algorithm can be executed with the run() function.  After it
-  /// the matching (the primal solution) and the barrier (the dual
-  /// solution) can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxFractionalMatching::primalScale "2".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-#ifdef DOXYGEN
-  template <typename GR, typename TR>
-#else
-  template <typename GR,
-            typename TR = MaxFractionalMatchingDefaultTraits<GR> >
-#endif
-  class MaxFractionalMatching {
-  public:
-
-    /// \brief The \ref lemon::MaxFractionalMatchingDefaultTraits
-    /// "traits class" of the algorithm.
-    typedef TR Traits;
-    /// The type of the graph the algorithm runs on.
-    typedef typename TR::Graph Graph;
-    /// The type of the matching map.
-    typedef typename TR::MatchingMap MatchingMap;
-    /// The type of the elevator.
-    typedef typename TR::Elevator Elevator;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-  private:
-
-    const Graph &_graph;
-    int _node_num;
-    bool _allow_loops;
-    int _empty_level;
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    bool _local_matching;
-    MatchingMap *_matching;
-
-    bool _local_level;
-    Elevator *_level;
-
-    typedef typename Graph::template NodeMap<int> InDegMap;
-    InDegMap *_indeg;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _local_matching = true;
-        _matching = Traits::createMatchingMap(_graph);
-      }
-      if (!_level) {
-        _local_level = true;
-        _level = Traits::createElevator(_graph, _node_num);
-      }
-      if (!_indeg) {
-        _indeg = new InDegMap(_graph);
-      }
-    }
-
-    void destroyStructures() {
-      if (_local_matching) {
-        delete _matching;
-      }
-      if (_local_level) {
-        delete _level;
-      }
-      if (_indeg) {
-        delete _indeg;
-      }
-    }
-
-    void postprocessing() {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] != 0) continue;
-        _indeg->set(n, -1);
-        Node u = n;
-        while ((*_matching)[u] != INVALID) {
-          Node v = _graph.target((*_matching)[u]);
-          _indeg->set(v, -1);
-          Arc a = _graph.oppositeArc((*_matching)[u]);
-          u = _graph.target((*_matching)[v]);
-          _indeg->set(u, -1);
-          _matching->set(v, a);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] != 1) continue;
-        _indeg->set(n, -1);
-
-        int num = 1;
-        Node u = _graph.target((*_matching)[n]);
-        while (u != n) {
-          _indeg->set(u, -1);
-          u = _graph.target((*_matching)[u]);
-          ++num;
-        }
-        if (num % 2 == 0 && num > 2) {
-          Arc prev = _graph.oppositeArc((*_matching)[n]);
-          Node v = _graph.target((*_matching)[n]);
-          u = _graph.target((*_matching)[v]);
-          _matching->set(v, prev);
-          while (u != n) {
-            prev = _graph.oppositeArc((*_matching)[u]);
-            v = _graph.target((*_matching)[u]);
-            u = _graph.target((*_matching)[v]);
-            _matching->set(v, prev);
-          }
-        }
-      }
-    }
-
-  public:
-
-    typedef MaxFractionalMatching Create;
-
-    ///\name Named Template Parameters
-
-    ///@{
-
-    template <typename T>
-    struct SetMatchingMapTraits : public Traits {
-      typedef T MatchingMap;
-      static MatchingMap *createMatchingMap(const Graph&) {
-        LEMON_ASSERT(false, "MatchingMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// MatchingMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting MatchingMap
-    /// type.
-    template <typename T>
-    struct SetMatchingMap
-      : public MaxFractionalMatching<Graph, SetMatchingMapTraits<T> > {
-      typedef MaxFractionalMatching<Graph, SetMatchingMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Graph&, int) {
-        LEMON_ASSERT(false, "Elevator is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// Elevator type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting Elevator
-    /// type. If this named parameter is used, then an external
-    /// elevator object must be passed to the algorithm using the
-    /// \ref elevator(Elevator&) "elevator()" function before calling
-    /// \ref run() or \ref init().
-    /// \sa SetStandardElevator
-    template <typename T>
-    struct SetElevator
-      : public MaxFractionalMatching<Graph, SetElevatorTraits<T> > {
-      typedef MaxFractionalMatching<Graph, SetElevatorTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetStandardElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Graph& graph, int max_level) {
-        return new Elevator(graph, max_level);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// Elevator type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting Elevator
-    /// type with automatic allocation.
-    /// The Elevator should have standard constructor interface to be
-    /// able to automatically created by the algorithm (i.e. the
-    /// graph and the maximum level should be passed to it).
-    /// However an external elevator object could also be passed to the
-    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
-    /// before calling \ref run() or \ref init().
-    /// \sa SetElevator
-    template <typename T>
-    struct SetStandardElevator
-      : public MaxFractionalMatching<Graph, SetStandardElevatorTraits<T> > {
-      typedef MaxFractionalMatching<Graph,
-                                    SetStandardElevatorTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    MaxFractionalMatching() {}
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    ///
-    MaxFractionalMatching(const Graph &graph, bool allow_loops = true)
-      : _graph(graph), _allow_loops(allow_loops),
-        _local_matching(false), _matching(0),
-        _local_level(false), _level(0),  _indeg(0)
-    {}
-
-    ~MaxFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the matching map.
-    ///
-    /// Sets the matching map.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    MaxFractionalMatching& matchingMap(MatchingMap& map) {
-      if (_local_matching) {
-        delete _matching;
-        _local_matching = false;
-      }
-      _matching = &map;
-      return *this;
-    }
-
-    /// \brief Sets the elevator used by algorithm.
-    ///
-    /// Sets the elevator used by algorithm.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated elevator,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    MaxFractionalMatching& elevator(Elevator& elevator) {
-      if (_local_level) {
-        delete _level;
-        _local_level = false;
-      }
-      _level = &elevator;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the elevator.
-    ///
-    /// Returns a const reference to the elevator.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const Elevator& elevator() const {
-      return *_level;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use one of the
-    /// member functions called \c run(). \n
-    /// If you need more control on the execution, first
-    /// you must call \ref init() and then one variant of the start()
-    /// member.
-
-    /// @{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// matching.
-    void init() {
-      createStructures();
-
-      _level->initStart();
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _indeg->set(n, 0);
-        _matching->set(n, INVALID);
-        _level->initAddItem(n);
-      }
-      _level->initFinish();
-
-      _empty_level = _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        for (OutArcIt a(_graph, n); a != INVALID; ++a) {
-          if (_graph.target(a) == n && !_allow_loops) continue;
-          _matching->set(n, a);
-          Node v = _graph.target((*_matching)[n]);
-          _indeg->set(v, (*_indeg)[v] + 1);
-          break;
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] == 0) {
-          _level->activate(n);
-        }
-      }
-    }
-
-    /// \brief Starts the algorithm and computes a fractional matching
-    ///
-    /// The algorithm computes a maximum fractional matching.
-    ///
-    /// \param postprocess The algorithm computes first a matching
-    /// which is a union of a matching with one value edges, cycles
-    /// with half value edges and even length paths with half value
-    /// edges. If the parameter is true, then after the push-relabel
-    /// algorithm it postprocesses the matching to contain only
-    /// matching edges and half value odd cycles.
-    void start(bool postprocess = true) {
-      Node n;
-      while ((n = _level->highestActive()) != INVALID) {
-        int level = _level->highestActiveLevel();
-        int new_level = _level->maxLevel();
-        for (InArcIt a(_graph, n); a != INVALID; ++a) {
-          Node u = _graph.source(a);
-          if (n == u && !_allow_loops) continue;
-          Node v = _graph.target((*_matching)[u]);
-          if ((*_level)[v] < level) {
-            _indeg->set(v, (*_indeg)[v] - 1);
-            if ((*_indeg)[v] == 0) {
-              _level->activate(v);
-            }
-            _matching->set(u, a);
-            _indeg->set(n, (*_indeg)[n] + 1);
-            _level->deactivate(n);
-            goto no_more_push;
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-        if (new_level + 1 < _level->maxLevel()) {
-          _level->liftHighestActive(new_level + 1);
-        } else {
-          _level->liftHighestActiveToTop();
-        }
-        if (_level->emptyLevel(level)) {
-          _level->liftToTop(level);
-        }
-      no_more_push:
-        ;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] == INVALID) continue;
-        Node u = _graph.target((*_matching)[n]);
-        if ((*_indeg)[u] > 1) {
-          _indeg->set(u, (*_indeg)[u] - 1);
-          _matching->set(n, INVALID);
-        }
-      }
-      if (postprocess) {
-        postprocessing();
-      }
-    }
-
-    /// \brief Starts the algorithm and computes a perfect fractional
-    /// matching
-    ///
-    /// The algorithm computes a perfect fractional matching. If it
-    /// does not exists, then the algorithm returns false and the
-    /// matching is undefined and the barrier.
-    ///
-    /// \param postprocess The algorithm computes first a matching
-    /// which is a union of a matching with one value edges, cycles
-    /// with half value edges and even length paths with half value
-    /// edges. If the parameter is true, then after the push-relabel
-    /// algorithm it postprocesses the matching to contain only
-    /// matching edges and half value odd cycles.
-    bool startPerfect(bool postprocess = true) {
-      Node n;
-      while ((n = _level->highestActive()) != INVALID) {
-        int level = _level->highestActiveLevel();
-        int new_level = _level->maxLevel();
-        for (InArcIt a(_graph, n); a != INVALID; ++a) {
-          Node u = _graph.source(a);
-          if (n == u && !_allow_loops) continue;
-          Node v = _graph.target((*_matching)[u]);
-          if ((*_level)[v] < level) {
-            _indeg->set(v, (*_indeg)[v] - 1);
-            if ((*_indeg)[v] == 0) {
-              _level->activate(v);
-            }
-            _matching->set(u, a);
-            _indeg->set(n, (*_indeg)[n] + 1);
-            _level->deactivate(n);
-            goto no_more_push;
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-        if (new_level + 1 < _level->maxLevel()) {
-          _level->liftHighestActive(new_level + 1);
-        } else {
-          _level->liftHighestActiveToTop();
-          _empty_level = _level->maxLevel() - 1;
-          return false;
-        }
-        if (_level->emptyLevel(level)) {
-          _level->liftToTop(level);
-          _empty_level = level;
-          return false;
-        }
-      no_more_push:
-        ;
-      }
-      if (postprocess) {
-        postprocessing();
-      }
-      return true;
-    }
-
-    /// \brief Runs the algorithm
-    ///
-    /// Just a shortcut for the next code:
-    ///\code
-    /// init();
-    /// start();
-    ///\endcode
-    void run(bool postprocess = true) {
-      init();
-      start(postprocess);
-    }
-
-    /// \brief Runs the algorithm to find a perfect fractional matching
-    ///
-    /// Just a shortcut for the next code:
-    ///\code
-    /// init();
-    /// startPerfect();
-    ///\endcode
-    bool runPerfect(bool postprocess = true) {
-      init();
-      return startPerfect(postprocess);
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    /// The result of the %Matching algorithm can be obtained using these
-    /// functions.\n
-    /// Before the use of these functions,
-    /// either run() or start() must be called.
-    ///@{
-
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Returns a const reference to the matching map.
-    ///
-    /// Returns a const reference to the node map storing the found
-    /// fractional matching. This method can be called after
-    /// running the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0) +
-        (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Returns true if the node is in the barrier
-    ///
-    /// The barrier is a subset of the nodes. If the nodes in the
-    /// barrier have less adjacent nodes than the size of the barrier,
-    /// then at least as much nodes cannot be covered as the
-    /// difference of the two subsets.
-    bool barrier(const Node& node) const {
-      return (*_level)[node] >= _empty_level;
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted fractional matching in general graphs
-  ///
-  /// This class provides an efficient implementation of fractional
-  /// matching algorithm. The implementation uses priority queues and
-  /// provides \f$O(nm\log n)\f$ time complexity.
-  ///
-  /// The maximum weighted fractional matching is a relaxation of the
-  /// maximum weighted matching problem where the odd set constraints
-  /// are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_ew_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result must be the union of a matching with one
-  /// value edges and a set of odd length cycles with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// proof of the optimality. The solution of the dual problem can be
-  /// used to check the result of the algorithm. The dual linear
-  /// problem is the following.
-  /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f]
-  /// \f[y_u \ge 0 \quad \forall u \in V\f]
-  /// \f[\min \sum_{u \in V}y_u \f]
-  ///
-  /// The algorithm can be executed with the run() function.
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxWeightedFractionalMatching::primalScale "2".
-  /// If the value type is integer, then the dual
-  /// solution is scaled by
-  /// \ref MaxWeightedFractionalMatching::dualScale "4".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
-#endif
-  class MaxWeightedFractionalMatching {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The type of the edge weight map
-    typedef WM WeightMap;
-    /// The value type of the edge weights
-    typedef typename WeightMap::Value Value;
-
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-    /// \brief Scaling factor for dual solution
-    ///
-    /// Scaling factor for dual solution. It is equal to 4 or 1
-    /// according to the value type.
-    static const int dualScale =
-      std::numeric_limits<Value>::is_integer ? 4 : 1;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef typename Graph::template NodeMap<Value> NodePotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-    NodePotential* _node_potential;
-
-    int _node_num;
-    bool _allow_loops;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef typename Graph::template NodeMap<Status> StatusMap;
-    StatusMap* _status;
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-    PredMap* _pred;
-
-    typedef ExtendFindEnum<IntNodeMap> TreeSet;
-
-    IntNodeMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntNodeMap *_delta1_index;
-    BinHeap<Value, IntNodeMap> *_delta1;
-
-    IntNodeMap *_delta2_index;
-    BinHeap<Value, IntNodeMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    Value _delta_sum;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-      if (!_status) {
-        _status = new StatusMap(_graph);
-      }
-      if (!_pred) {
-        _pred = new PredMap(_graph);
-      }
-      if (!_tree_set) {
-        _tree_set_index = new IntNodeMap(_graph);
-        _tree_set = new TreeSet(*_tree_set_index);
-      }
-      if (!_delta1) {
-        _delta1_index = new IntNodeMap(_graph);
-        _delta1 = new BinHeap<Value, IntNodeMap>(*_delta1_index);
-      }
-      if (!_delta2) {
-        _delta2_index = new IntNodeMap(_graph);
-        _delta2 = new BinHeap<Value, IntNodeMap>(*_delta2_index);
-      }
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_status) {
-        delete _status;
-      }
-      if (_pred) {
-        delete _pred;
-      }
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-      if (_delta1) {
-        delete _delta1_index;
-        delete _delta1;
-      }
-      if (_delta2) {
-        delete _delta2_index;
-        delete _delta2;
-      }
-      if (_delta3) {
-        delete _delta3_index;
-        delete _delta3;
-      }
-    }
-
-    void matchedToEven(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      _delta1->push(node, (*_node_potential)[node]);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->push(a, rw / 2);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->push(a, rw / 2);
-        } else if ((*_status)[v] == MATCHED) {
-          if (_delta2->state(v) != _delta2->IN_HEAP) {
-            _pred->set(v, a);
-            _delta2->push(v, rw);
-          } else if ((*_delta2)[v] > rw) {
-            _pred->set(v, a);
-            _delta2->decrease(v, rw);
-          }
-        }
-      }
-    }
-
-    void matchedToOdd(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-    }
-
-    void evenToMatched(Node node, int tree) {
-      _delta1->erase(node);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->erase(a);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->erase(a);
-          if (minrw > rw) {
-            min = _graph.oppositeArc(a);
-            minrw = rw;
-          }
-        } else if ((*_status)[v]  == MATCHED) {
-          if ((*_pred)[v] == a) {
-            Arc mina = INVALID;
-            Value minrwa = std::numeric_limits<Value>::max();
-            for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) {
-              Node va = _graph.target(aa);
-              if ((*_status)[va] != EVEN ||
-                  _tree_set->find(va) == tree) continue;
-              Value rwa = (*_node_potential)[v] + (*_node_potential)[va] -
-                dualScale * _weight[aa];
-              if (minrwa > rwa) {
-                minrwa = rwa;
-                mina = aa;
-              }
-            }
-            if (mina != INVALID) {
-              _pred->set(v, mina);
-              _delta2->increase(v, minrwa);
-            } else {
-              _pred->set(v, INVALID);
-              _delta2->erase(v);
-            }
-          }
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void oddToMatched(Node node) {
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        if ((*_status)[v] != EVEN) continue;
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (minrw > rw) {
-          min = _graph.oppositeArc(a);
-          minrw = rw;
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void alternatePath(Node even, int tree) {
-      Node odd;
-
-      _status->set(even, MATCHED);
-      evenToMatched(even, tree);
-
-      Arc prev = (*_matching)[even];
-      while (prev != INVALID) {
-        odd = _graph.target(prev);
-        even = _graph.target((*_pred)[odd]);
-        _matching->set(odd, (*_pred)[odd]);
-        _status->set(odd, MATCHED);
-        oddToMatched(odd);
-
-        prev = (*_matching)[even];
-        _status->set(even, MATCHED);
-        _matching->set(even, _graph.oppositeArc((*_matching)[odd]));
-        evenToMatched(even, tree);
-      }
-    }
-
-    void destroyTree(int tree) {
-      for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) {
-        if ((*_status)[n] == EVEN) {
-          _status->set(n, MATCHED);
-          evenToMatched(n, tree);
-        } else if ((*_status)[n] == ODD) {
-          _status->set(n, MATCHED);
-          oddToMatched(n);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-
-    void unmatchNode(const Node& node) {
-      int tree = _tree_set->find(node);
-
-      alternatePath(node, tree);
-      destroyTree(tree);
-
-      _matching->set(node, INVALID);
-    }
-
-
-    void augmentOnEdge(const Edge& edge) {
-      Node left = _graph.u(edge);
-      int left_tree = _tree_set->find(left);
-
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-      _matching->set(left, _graph.direct(edge, true));
-
-      Node right = _graph.v(edge);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.direct(edge, false));
-    }
-
-    void augmentOnArc(const Arc& arc) {
-      Node left = _graph.source(arc);
-      _status->set(left, MATCHED);
-      _matching->set(left, arc);
-      _pred->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-    void extendOnArc(const Arc& arc) {
-      Node base = _graph.target(arc);
-      int tree = _tree_set->find(base);
-
-      Node odd = _graph.source(arc);
-      _tree_set->insert(odd, tree);
-      _status->set(odd, ODD);
-      matchedToOdd(odd, tree);
-      _pred->set(odd, arc);
-
-      Node even = _graph.target((*_matching)[odd]);
-      _tree_set->insert(even, tree);
-      _status->set(even, EVEN);
-      matchedToEven(even, tree);
-    }
-
-    void cycleOnEdge(const Edge& edge, int tree) {
-      Node nca = INVALID;
-      std::vector<Node> left_path, right_path;
-
-      {
-        std::set<Node> left_set, right_set;
-        Node left = _graph.u(edge);
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        Node right = _graph.v(edge);
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-          if ((*_matching)[left] == INVALID) break;
-
-          left = _graph.target((*_matching)[left]);
-          left_path.push_back(left);
-          left = _graph.target((*_pred)[left]);
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_matching)[right] == INVALID) break;
-
-          right = _graph.target((*_matching)[right]);
-          right_path.push_back(right);
-          right = _graph.target((*_pred)[right]);
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-        }
-
-        if (nca == INVALID) {
-          if ((*_matching)[left] == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              right_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              left_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      alternatePath(nca, tree);
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        _matching->set(left_path[i], prev);
-        _status->set(left_path[i], MATCHED);
-        evenToMatched(left_path[i], tree);
-
-        prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]);
-        _status->set(left_path[i + 1], MATCHED);
-        oddToMatched(left_path[i + 1]);
-      }
-      _matching->set(nca, prev);
-
-      for (int i = 0; right_path[i] != nca; i += 2) {
-        _status->set(right_path[i], MATCHED);
-        evenToMatched(right_path[i], tree);
-
-        _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]);
-        _status->set(right_path[i + 1], MATCHED);
-        oddToMatched(right_path[i + 1]);
-      }
-
-      destroyTree(tree);
-    }
-
-    void extractCycle(const Arc &arc) {
-      Node left = _graph.source(arc);
-      Node odd = _graph.target((*_matching)[left]);
-      Arc prev;
-      while (odd != left) {
-        Node even = _graph.target((*_matching)[odd]);
-        prev = (*_matching)[odd];
-        odd = _graph.target((*_matching)[even]);
-        _matching->set(even, _graph.oppositeArc(prev));
-      }
-      _matching->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedFractionalMatching(const Graph& graph, const WeightMap& weight,
-                                  bool allow_loops = true)
-      : _graph(graph), _weight(weight), _matching(0),
-      _node_potential(0), _node_num(0), _allow_loops(allow_loops),
-      _status(0),  _pred(0),
-      _tree_set_index(0), _tree_set(0),
-
-      _delta1_index(0), _delta1(0),
-      _delta2_index(0), _delta2(0),
-      _delta3_index(0), _delta3(0),
-
-      _delta_sum() {}
-
-    ~MaxWeightedFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
-
-    ///@{
-
-    /// \brief Initialize the algorithm
-    ///
-    /// This function initializes the algorithm.
-    void init() {
-      createStructures();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta1_index)[n] = _delta1->PRE_HEAP;
-        (*_delta2_index)[n] = _delta2->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-
-      _delta1->clear();
-      _delta2->clear();
-      _delta3->clear();
-      _tree_set->clear();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value max = 0;
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          if (_graph.target(e) == n && !_allow_loops) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        _node_potential->set(n, max);
-        _delta1->push(n, max);
-
-        _tree_set->insert(n);
-
-        _matching->set(n, INVALID);
-        _status->set(n, EVEN);
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        Node left = _graph.u(e);
-        Node right = _graph.v(e);
-        if (left == right && !_allow_loops) continue;
-        _delta3->push(e, ((*_node_potential)[left] +
-                          (*_node_potential)[right] -
-                          dualScale * _weight[e]) / 2);
-      }
-    }
-
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
-    void start() {
-      enum OpType {
-        D1, D2, D3
-      };
-
-      int unmatched = _node_num;
-      while (unmatched > 0) {
-        Value d1 = !_delta1->empty() ?
-          _delta1->prio() : std::numeric_limits<Value>::max();
-
-        Value d2 = !_delta2->empty() ?
-          _delta2->prio() : std::numeric_limits<Value>::max();
-
-        Value d3 = !_delta3->empty() ?
-          _delta3->prio() : std::numeric_limits<Value>::max();
-
-        _delta_sum = d3; OpType ot = D3;
-        if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; }
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
-
-        switch (ot) {
-        case D1:
-          {
-            Node n = _delta1->top();
-            unmatchNode(n);
-            --unmatched;
-          }
-          break;
-        case D2:
-          {
-            Node n = _delta2->top();
-            Arc a = (*_pred)[n];
-            if ((*_matching)[n] == INVALID) {
-              augmentOnArc(a);
-              --unmatched;
-            } else {
-              Node v = _graph.target((*_matching)[n]);
-              if ((*_matching)[n] !=
-                  _graph.oppositeArc((*_matching)[v])) {
-                extractCycle(a);
-                --unmatched;
-              } else {
-                extendOnArc(a);
-              }
-            }
-          } break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            Node left = _graph.u(e);
-            Node right = _graph.v(e);
-
-            int left_tree = _tree_set->find(left);
-            int right_tree = _tree_set->find(right);
-
-            if (left_tree == right_tree) {
-              cycleOnEdge(e, left_tree);
-              --unmatched;
-            } else {
-              augmentOnEdge(e);
-              unmatched -= 2;
-            }
-          } break;
-        }
-      }
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedFractionalMatching algorithm.
-    ///
-    /// \note mwfm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwfm.init();
-    ///   mwfm.start();
-    /// \endcode
-    void run() {
-      init();
-      start();
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
-    /// matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching. This
-    /// value is scaled by \ref primalScale "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value matchingWeight() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          sum += _weight[(*_matching)[n]];
-        }
-      }
-      return sum * primalScale / 2;
-    }
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0)
-        + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Return a const reference to the matching map.
-    ///
-    /// This function returns a const reference to a node map that stores
-    /// the matching arc (or edge) incident to each node.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// @}
-
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value dualValue() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sum += nodeValue(n);
-      }
-      return sum;
-    }
-
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value nodeValue(const Node& n) const {
-      return (*_node_potential)[n];
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted fractional perfect matching in general graphs
-  ///
-  /// This class provides an efficient implementation of fractional
-  /// matching algorithm. The implementation uses priority queues and
-  /// provides \f$O(nm\log n)\f$ time complexity.
-  ///
-  /// The maximum weighted fractional perfect matching is a relaxation
-  /// of the maximum weighted perfect matching problem where the odd
-  /// set constraints are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_ew_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result must be the union of a matching with one
-  /// value edges and a set of odd length cycles with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// proof of the optimality. The solution of the dual problem can be
-  /// used to check the result of the algorithm. The dual linear
-  /// problem is the following.
-  /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f]
-  /// \f[\min \sum_{u \in V}y_u \f]
-  ///
-  /// The algorithm can be executed with the run() function.
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxWeightedPerfectFractionalMatching::primalScale "2".
-  /// If the value type is integer, then the dual
-  /// solution is scaled by
-  /// \ref MaxWeightedPerfectFractionalMatching::dualScale "4".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
-#endif
-  class MaxWeightedPerfectFractionalMatching {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The type of the edge weight map
-    typedef WM WeightMap;
-    /// The value type of the edge weights
-    typedef typename WeightMap::Value Value;
-
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-    /// \brief Scaling factor for dual solution
-    ///
-    /// Scaling factor for dual solution. It is equal to 4 or 1
-    /// according to the value type.
-    static const int dualScale =
-      std::numeric_limits<Value>::is_integer ? 4 : 1;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef typename Graph::template NodeMap<Value> NodePotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-    NodePotential* _node_potential;
-
-    int _node_num;
-    bool _allow_loops;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef typename Graph::template NodeMap<Status> StatusMap;
-    StatusMap* _status;
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-    PredMap* _pred;
-
-    typedef ExtendFindEnum<IntNodeMap> TreeSet;
-
-    IntNodeMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntNodeMap *_delta2_index;
-    BinHeap<Value, IntNodeMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    Value _delta_sum;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-      if (!_status) {
-        _status = new StatusMap(_graph);
-      }
-      if (!_pred) {
-        _pred = new PredMap(_graph);
-      }
-      if (!_tree_set) {
-        _tree_set_index = new IntNodeMap(_graph);
-        _tree_set = new TreeSet(*_tree_set_index);
-      }
-      if (!_delta2) {
-        _delta2_index = new IntNodeMap(_graph);
-        _delta2 = new BinHeap<Value, IntNodeMap>(*_delta2_index);
-      }
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_status) {
-        delete _status;
-      }
-      if (_pred) {
-        delete _pred;
-      }
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-      if (_delta2) {
-        delete _delta2_index;
-        delete _delta2;
-      }
-      if (_delta3) {
-        delete _delta3_index;
-        delete _delta3;
-      }
-    }
-
-    void matchedToEven(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->push(a, rw / 2);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->push(a, rw / 2);
-        } else if ((*_status)[v] == MATCHED) {
-          if (_delta2->state(v) != _delta2->IN_HEAP) {
-            _pred->set(v, a);
-            _delta2->push(v, rw);
-          } else if ((*_delta2)[v] > rw) {
-            _pred->set(v, a);
-            _delta2->decrease(v, rw);
-          }
-        }
-      }
-    }
-
-    void matchedToOdd(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-    }
-
-    void evenToMatched(Node node, int tree) {
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->erase(a);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->erase(a);
-          if (minrw > rw) {
-            min = _graph.oppositeArc(a);
-            minrw = rw;
-          }
-        } else if ((*_status)[v]  == MATCHED) {
-          if ((*_pred)[v] == a) {
-            Arc mina = INVALID;
-            Value minrwa = std::numeric_limits<Value>::max();
-            for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) {
-              Node va = _graph.target(aa);
-              if ((*_status)[va] != EVEN ||
-                  _tree_set->find(va) == tree) continue;
-              Value rwa = (*_node_potential)[v] + (*_node_potential)[va] -
-                dualScale * _weight[aa];
-              if (minrwa > rwa) {
-                minrwa = rwa;
-                mina = aa;
-              }
-            }
-            if (mina != INVALID) {
-              _pred->set(v, mina);
-              _delta2->increase(v, minrwa);
-            } else {
-              _pred->set(v, INVALID);
-              _delta2->erase(v);
-            }
-          }
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void oddToMatched(Node node) {
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        if ((*_status)[v] != EVEN) continue;
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (minrw > rw) {
-          min = _graph.oppositeArc(a);
-          minrw = rw;
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void alternatePath(Node even, int tree) {
-      Node odd;
-
-      _status->set(even, MATCHED);
-      evenToMatched(even, tree);
-
-      Arc prev = (*_matching)[even];
-      while (prev != INVALID) {
-        odd = _graph.target(prev);
-        even = _graph.target((*_pred)[odd]);
-        _matching->set(odd, (*_pred)[odd]);
-        _status->set(odd, MATCHED);
-        oddToMatched(odd);
-
-        prev = (*_matching)[even];
-        _status->set(even, MATCHED);
-        _matching->set(even, _graph.oppositeArc((*_matching)[odd]));
-        evenToMatched(even, tree);
-      }
-    }
-
-    void destroyTree(int tree) {
-      for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) {
-        if ((*_status)[n] == EVEN) {
-          _status->set(n, MATCHED);
-          evenToMatched(n, tree);
-        } else if ((*_status)[n] == ODD) {
-          _status->set(n, MATCHED);
-          oddToMatched(n);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-    void augmentOnEdge(const Edge& edge) {
-      Node left = _graph.u(edge);
-      int left_tree = _tree_set->find(left);
-
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-      _matching->set(left, _graph.direct(edge, true));
-
-      Node right = _graph.v(edge);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.direct(edge, false));
-    }
-
-    void augmentOnArc(const Arc& arc) {
-      Node left = _graph.source(arc);
-      _status->set(left, MATCHED);
-      _matching->set(left, arc);
-      _pred->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-    void extendOnArc(const Arc& arc) {
-      Node base = _graph.target(arc);
-      int tree = _tree_set->find(base);
-
-      Node odd = _graph.source(arc);
-      _tree_set->insert(odd, tree);
-      _status->set(odd, ODD);
-      matchedToOdd(odd, tree);
-      _pred->set(odd, arc);
-
-      Node even = _graph.target((*_matching)[odd]);
-      _tree_set->insert(even, tree);
-      _status->set(even, EVEN);
-      matchedToEven(even, tree);
-    }
-
-    void cycleOnEdge(const Edge& edge, int tree) {
-      Node nca = INVALID;
-      std::vector<Node> left_path, right_path;
-
-      {
-        std::set<Node> left_set, right_set;
-        Node left = _graph.u(edge);
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        Node right = _graph.v(edge);
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-          if ((*_matching)[left] == INVALID) break;
-
-          left = _graph.target((*_matching)[left]);
-          left_path.push_back(left);
-          left = _graph.target((*_pred)[left]);
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_matching)[right] == INVALID) break;
-
-          right = _graph.target((*_matching)[right]);
-          right_path.push_back(right);
-          right = _graph.target((*_pred)[right]);
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-        }
-
-        if (nca == INVALID) {
-          if ((*_matching)[left] == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              right_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              left_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      alternatePath(nca, tree);
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        _matching->set(left_path[i], prev);
-        _status->set(left_path[i], MATCHED);
-        evenToMatched(left_path[i], tree);
-
-        prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]);
-        _status->set(left_path[i + 1], MATCHED);
-        oddToMatched(left_path[i + 1]);
-      }
-      _matching->set(nca, prev);
-
-      for (int i = 0; right_path[i] != nca; i += 2) {
-        _status->set(right_path[i], MATCHED);
-        evenToMatched(right_path[i], tree);
-
-        _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]);
-        _status->set(right_path[i + 1], MATCHED);
-        oddToMatched(right_path[i + 1]);
-      }
-
-      destroyTree(tree);
-    }
-
-    void extractCycle(const Arc &arc) {
-      Node left = _graph.source(arc);
-      Node odd = _graph.target((*_matching)[left]);
-      Arc prev;
-      while (odd != left) {
-        Node even = _graph.target((*_matching)[odd]);
-        prev = (*_matching)[odd];
-        odd = _graph.target((*_matching)[even]);
-        _matching->set(even, _graph.oppositeArc(prev));
-      }
-      _matching->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedPerfectFractionalMatching(const Graph& graph,
-                                         const WeightMap& weight,
-                                         bool allow_loops = true)
-      : _graph(graph), _weight(weight), _matching(0),
-      _node_potential(0), _node_num(0), _allow_loops(allow_loops),
-      _status(0),  _pred(0),
-      _tree_set_index(0), _tree_set(0),
-
-      _delta2_index(0), _delta2(0),
-      _delta3_index(0), _delta3(0),
-
-      _delta_sum() {}
-
-    ~MaxWeightedPerfectFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
-
-    ///@{
-
-    /// \brief Initialize the algorithm
-    ///
-    /// This function initializes the algorithm.
-    void init() {
-      createStructures();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta2_index)[n] = _delta2->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-
-      _delta2->clear();
-      _delta3->clear();
-      _tree_set->clear();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value max = - std::numeric_limits<Value>::max();
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          if (_graph.target(e) == n && !_allow_loops) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        _node_potential->set(n, max);
-
-        _tree_set->insert(n);
-
-        _matching->set(n, INVALID);
-        _status->set(n, EVEN);
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        Node left = _graph.u(e);
-        Node right = _graph.v(e);
-        if (left == right && !_allow_loops) continue;
-        _delta3->push(e, ((*_node_potential)[left] +
-                          (*_node_potential)[right] -
-                          dualScale * _weight[e]) / 2);
-      }
-    }
-
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
-    bool start() {
-      enum OpType {
-        D2, D3
-      };
-
-      int unmatched = _node_num;
-      while (unmatched > 0) {
-        Value d2 = !_delta2->empty() ?
-          _delta2->prio() : std::numeric_limits<Value>::max();
-
-        Value d3 = !_delta3->empty() ?
-          _delta3->prio() : std::numeric_limits<Value>::max();
-
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
-
-        if (_delta_sum == std::numeric_limits<Value>::max()) {
-          return false;
-        }
-
-        switch (ot) {
-        case D2:
-          {
-            Node n = _delta2->top();
-            Arc a = (*_pred)[n];
-            if ((*_matching)[n] == INVALID) {
-              augmentOnArc(a);
-              --unmatched;
-            } else {
-              Node v = _graph.target((*_matching)[n]);
-              if ((*_matching)[n] !=
-                  _graph.oppositeArc((*_matching)[v])) {
-                extractCycle(a);
-                --unmatched;
-              } else {
-                extendOnArc(a);
-              }
-            }
-          } break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            Node left = _graph.u(e);
-            Node right = _graph.v(e);
-
-            int left_tree = _tree_set->find(left);
-            int right_tree = _tree_set->find(right);
-
-            if (left_tree == right_tree) {
-              cycleOnEdge(e, left_tree);
-              --unmatched;
-            } else {
-              augmentOnEdge(e);
-              unmatched -= 2;
-            }
-          } break;
-        }
-      }
-      return true;
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedPerfectFractionalMatching
-    /// algorithm.
-    ///
-    /// \note mwfm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwpfm.init();
-    ///   mwpfm.start();
-    /// \endcode
-    bool run() {
-      init();
-      return start();
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
-    /// matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching. This
-    /// value is scaled by \ref primalScale "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value matchingWeight() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          sum += _weight[(*_matching)[n]];
-        }
-      }
-      return sum * primalScale / 2;
-    }
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0)
-        + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Return a const reference to the matching map.
-    ///
-    /// This function returns a const reference to a node map that stores
-    /// the matching arc (or edge) incident to each node.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// @}
-
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value dualValue() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sum += nodeValue(n);
-      }
-      return sum;
-    }
-
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value nodeValue(const Node& n) const {
-      return (*_node_potential)[n];
-    }
-
-    /// @}
-
-  };
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_FRACTIONAL_MATCHING_H
Index: lemon/full_graph.h
===================================================================
--- lemon/full_graph.h	(revision 1193)
+++ lemon/full_graph.h	(revision 664)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -25,5 +25,5 @@
 ///\ingroup graphs
 ///\file
-///\brief FullDigraph and FullGraph classes.
+///\brief FullGraph and FullDigraph classes.
 
 namespace lemon {
@@ -52,5 +52,5 @@
 
     Node operator()(int ix) const { return Node(ix); }
-    static int index(const Node& node) { return node._id; }
+    int index(const Node& node) const { return node._id; }
 
     Arc arc(const Node& s, const Node& t) const {
@@ -149,26 +149,22 @@
   /// \ingroup graphs
   ///
-  /// \brief A directed full graph class.
-  ///
-  /// FullDigraph is a simple and fast implmenetation of directed full
-  /// (complete) graphs. It contains an arc from each node to each node
-  /// (including a loop for each node), therefore the number of arcs
-  /// is the square of the number of nodes.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or arcs, however
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes and arcs.
-  ///
-  /// \note FullDigraph and FullGraph classes are very similar,
+  /// \brief A full digraph class.
+  ///
+  /// This is a simple and fast directed full graph implementation.
+  /// From each node go arcs to each node (including the source node),
+  /// therefore the number of the arcs in the digraph is the square of
+  /// the node number. This digraph type is completely static, so you
+  /// can neither add nor delete either arcs or nodes, and it needs
+  /// constant space in memory.
+  ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph concept".
+  ///
+  /// The \c FullDigraph and \c FullGraph classes are very similar,
   /// but there are two differences. While this class conforms only
-  /// to the \ref concepts::Digraph "Digraph" concept, FullGraph
-  /// conforms to the \ref concepts::Graph "Graph" concept,
-  /// moreover FullGraph does not contain a loop for each
-  /// node as this class does.
+  /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph
+  /// class conforms to the \ref concepts::Graph "Graph" concept,
+  /// moreover \c FullGraph does not contain a loop arc for each
+  /// node as \c FullDigraph does.
   ///
   /// \sa FullGraph
@@ -178,7 +174,5 @@
   public:
 
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and arcs will be zero.
+    /// \brief Constructor
     FullDigraph() { construct(0); }
 
@@ -191,6 +185,6 @@
     /// \brief Resizes the digraph
     ///
-    /// This function resizes the digraph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the digraph will be
+    /// Resizes the digraph. The function will fully destroy and
+    /// rebuild the digraph. This cause that the maps of the digraph will
     /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
@@ -204,8 +198,7 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
+    /// Returns the node with the given index. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -213,15 +206,14 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
-    /// \sa operator()()
-    static int index(const Node& node) { return Parent::index(node); }
+    /// Returns the index of the given node. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \sa operator()
+    int index(const Node& node) const { return Parent::index(node); }
 
     /// \brief Returns the arc connecting the given nodes.
     ///
     /// Returns the arc connecting the given nodes.
-    Arc arc(Node u, Node v) const {
+    Arc arc(const Node& u, const Node& v) const {
       return Parent::arc(u, v);
     }
@@ -292,5 +284,5 @@
 
     Node operator()(int ix) const { return Node(ix); }
-    static int index(const Node& node) { return node._id; }
+    int index(const Node& node) const { return node._id; }
 
     Edge edge(const Node& u, const Node& v) const {
@@ -529,23 +521,19 @@
   /// \brief An undirected full graph class.
   ///
-  /// FullGraph is a simple and fast implmenetation of undirected full
-  /// (complete) graphs. It contains an edge between every distinct pair
-  /// of nodes, therefore the number of edges is <tt>n(n-1)/2</tt>.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \note FullDigraph and FullGraph classes are very similar,
-  /// but there are two differences. While FullDigraph
+  /// This is a simple and fast undirected full graph
+  /// implementation. From each node go edge to each other node,
+  /// therefore the number of edges in the graph is \f$n(n-1)/2\f$.
+  /// This graph type is completely static, so you can neither
+  /// add nor delete either edges or nodes, and it needs constant
+  /// space in memory.
+  ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph concept".
+  ///
+  /// The \c FullGraph and \c FullDigraph classes are very similar,
+  /// but there are two differences. While the \c FullDigraph class
   /// conforms only to the \ref concepts::Digraph "Digraph" concept,
   /// this class conforms to the \ref concepts::Graph "Graph" concept,
-  /// moreover this class does not contain a loop for each
-  /// node as FullDigraph does.
+  /// moreover \c FullGraph does not contain a loop arc for each
+  /// node as \c FullDigraph does.
   ///
   /// \sa FullDigraph
@@ -555,7 +543,5 @@
   public:
 
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and edges will be zero.
+    /// \brief Constructor
     FullGraph() { construct(0); }
 
@@ -568,6 +554,6 @@
     /// \brief Resizes the graph
     ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
+    /// Resizes the graph. The function will fully destroy and
+    /// rebuild the graph. This cause that the maps of the graph will
     /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
@@ -583,8 +569,7 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
+    /// Returns the node with the given index. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -592,22 +577,21 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
-    /// \sa operator()()
-    static int index(const Node& node) { return Parent::index(node); }
+    /// Returns the index of the given node. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \sa operator()
+    int index(const Node& node) const { return Parent::index(node); }
 
     /// \brief Returns the arc connecting the given nodes.
     ///
     /// Returns the arc connecting the given nodes.
-    Arc arc(Node s, Node t) const {
+    Arc arc(const Node& s, const Node& t) const {
       return Parent::arc(s, t);
     }
 
-    /// \brief Returns the edge connecting the given nodes.
-    ///
-    /// Returns the edge connecting the given nodes.
-    Edge edge(Node u, Node v) const {
+    /// \brief Returns the edge connects the given nodes.
+    ///
+    /// Returns the edge connects the given nodes.
+    Edge edge(const Node& u, const Node& v) const {
       return Parent::edge(u, v);
     }
@@ -622,458 +606,4 @@
   };
 
-  class FullBpGraphBase {
-
-  protected:
-
-    int _red_num, _blue_num;
-    int _node_num, _edge_num;
-
-  public:
-
-    typedef FullBpGraphBase Graph;
-
-    class Node;
-    class Arc;
-    class Edge;
-
-    class Node {
-      friend class FullBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Node(int id) { _id = id;}
-
-    public:
-      Node() {}
-      Node (Invalid) { _id = -1; }
-      bool operator==(const Node& node) const {return _id == node._id;}
-      bool operator!=(const Node& node) const {return _id != node._id;}
-      bool operator<(const Node& node) const {return _id < node._id;}
-    };
-
-    class RedNode : public Node {
-      friend class FullBpGraphBase;
-    protected:
-
-      explicit RedNode(int pid) : Node(pid) {}
-
-    public:
-      RedNode() {}
-      RedNode(const RedNode& node) : Node(node) {}
-      RedNode(Invalid) : Node(INVALID){}
-    };
-
-    class BlueNode : public Node {
-      friend class FullBpGraphBase;
-    protected:
-
-      explicit BlueNode(int pid) : Node(pid) {}
-
-    public:
-      BlueNode() {}
-      BlueNode(const BlueNode& node) : Node(node) {}
-      BlueNode(Invalid) : Node(INVALID){}
-    };
-
-    class Edge {
-      friend class FullBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Edge(int id) { _id = id;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { _id = -1; }
-      bool operator==(const Edge& arc) const {return _id == arc._id;}
-      bool operator!=(const Edge& arc) const {return _id != arc._id;}
-      bool operator<(const Edge& arc) const {return _id < arc._id;}
-    };
-
-    class Arc {
-      friend class FullBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Arc(int id) { _id = id;}
-
-    public:
-      operator Edge() const {
-        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
-      }
-
-      Arc() {}
-      Arc (Invalid) { _id = -1; }
-      bool operator==(const Arc& arc) const {return _id == arc._id;}
-      bool operator!=(const Arc& arc) const {return _id != arc._id;}
-      bool operator<(const Arc& arc) const {return _id < arc._id;}
-    };
-
-
-  protected:
-
-    FullBpGraphBase()
-      : _red_num(0), _blue_num(0), _node_num(0), _edge_num(0) {}
-
-    void construct(int redNum, int blueNum) {
-      _red_num = redNum; _blue_num = blueNum;
-      _node_num = redNum + blueNum; _edge_num = redNum * blueNum;
-    }
-
-  public:
-
-    typedef True NodeNumTag;
-    typedef True EdgeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return _node_num; }
-    int redNum() const { return _red_num; }
-    int blueNum() const { return _blue_num; }
-    int edgeNum() const { return _edge_num; }
-    int arcNum() const { return 2 * _edge_num; }
-
-    int maxNodeId() const { return _node_num - 1; }
-    int maxRedId() const { return _red_num - 1; }
-    int maxBlueId() const { return _blue_num - 1; }
-    int maxEdgeId() const { return _edge_num - 1; }
-    int maxArcId() const { return 2 * _edge_num - 1; }
-
-    bool red(Node n) const { return n._id < _red_num; }
-    bool blue(Node n) const { return n._id >= _red_num; }
-
-    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
-    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
-
-    Node source(Arc a) const {
-      if (a._id & 1) {
-        return Node((a._id >> 1) % _red_num);
-      } else {
-        return Node((a._id >> 1) / _red_num + _red_num);
-      }
-    }
-    Node target(Arc a) const {
-      if (a._id & 1) {
-        return Node((a._id >> 1) / _red_num + _red_num);
-      } else {
-        return Node((a._id >> 1) % _red_num);
-      }
-    }
-
-    RedNode redNode(Edge e) const {
-      return RedNode(e._id % _red_num);
-    }
-    BlueNode blueNode(Edge e) const {
-      return BlueNode(e._id / _red_num + _red_num);
-    }
-
-    static bool direction(Arc a) {
-      return (a._id & 1) == 1;
-    }
-
-    static Arc direct(Edge e, bool d) {
-      return Arc(e._id * 2 + (d ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node._id = _node_num - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(RedNode& node) const {
-      node._id = _red_num - 1;
-    }
-
-    static void next(RedNode& node) {
-      --node._id;
-    }
-
-    void first(BlueNode& node) const {
-      if (_red_num == _node_num) node._id = -1;
-      else node._id = _node_num - 1;
-    }
-
-    void next(BlueNode& node) const {
-      if (node._id == _red_num) node._id = -1;
-      else --node._id;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = 2 * _edge_num - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void first(Edge& arc) const {
-      arc._id = _edge_num - 1;
-    }
-
-    static void next(Edge& arc) {
-      --arc._id;
-    }
-
-    void firstOut(Arc &a, const Node& v) const {
-      if (v._id < _red_num) {
-        a._id = 2 * (v._id + _red_num * (_blue_num - 1)) + 1;
-      } else {
-        a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num));
-      }
-    }
-    void nextOut(Arc &a) const {
-      if (a._id & 1) {
-        a._id -= 2 * _red_num;
-        if (a._id < 0) a._id = -1;
-      } else {
-        if (a._id % (2 * _red_num) == 0) a._id = -1;
-        else a._id -= 2;
-      }
-    }
-
-    void firstIn(Arc &a, const Node& v) const {
-      if (v._id < _red_num) {
-        a._id = 2 * (v._id + _red_num * (_blue_num - 1));
-      } else {
-        a._id = 2 * (_red_num - 1 + _red_num * (v._id - _red_num)) + 1;
-      }
-    }
-    void nextIn(Arc &a) const {
-      if (a._id & 1) {
-        if (a._id % (2 * _red_num) == 1) a._id = -1;
-        else a._id -= 2;
-      } else {
-        a._id -= 2 * _red_num;
-        if (a._id < 0) a._id = -1;
-      }
-    }
-
-    void firstInc(Edge &e, bool& d, const Node& v) const {
-      if (v._id < _red_num) {
-        d = true;
-        e._id = v._id + _red_num * (_blue_num - 1);
-      } else {
-        d = false;
-        e._id = _red_num - 1 + _red_num * (v._id - _red_num);
-      }
-    }
-    void nextInc(Edge &e, bool& d) const {
-      if (d) {
-        e._id -= _red_num;
-        if (e._id < 0) e._id = -1;
-      } else {
-        if (e._id % _red_num == 0) e._id = -1;
-        else --e._id;
-      }
-    }
-
-    static int id(const Node& v) { return v._id; }
-    int id(const RedNode& v) const { return v._id; }
-    int id(const BlueNode& v) const { return v._id - _red_num; }
-    static int id(Arc e) { return e._id; }
-    static int id(Edge e) { return e._id; }
-    
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    bool valid(Node n) const {
-      return n._id >= 0 && n._id < _node_num;
-    }
-    bool valid(Arc a) const {
-      return a._id >= 0 && a._id < 2 * _edge_num;
-    }
-    bool valid(Edge e) const {
-      return e._id >= 0 && e._id < _edge_num;
-    }
-
-    RedNode redNode(int index) const {
-      return RedNode(index);
-    }
-
-    int index(RedNode n) const {
-      return n._id;
-    }
-
-    BlueNode blueNode(int index) const {
-      return BlueNode(index + _red_num);
-    }
-
-    int index(BlueNode n) const {
-      return n._id - _red_num;
-    }
-        
-    void clear() {
-      _red_num = 0; _blue_num = 0;
-      _node_num = 0; _edge_num = 0;
-    }
-
-    Edge edge(const Node& u, const Node& v) const { 
-      if (u._id < _red_num) {
-        if (v._id < _red_num) {
-          return Edge(-1);
-        } else {
-          return Edge(u._id + _red_num * (v._id - _red_num));
-        }
-      } else {
-        if (v._id < _red_num) {
-          return Edge(v._id + _red_num * (u._id - _red_num));
-        } else {
-          return Edge(-1);
-        }
-      }
-    }
-
-    Arc arc(const Node& u, const Node& v) const { 
-      if (u._id < _red_num) {
-        if (v._id < _red_num) {
-          return Arc(-1);
-        } else {
-          return Arc(2 * (u._id + _red_num * (v._id - _red_num)) + 1);
-        }
-      } else {
-        if (v._id < _red_num) {
-          return Arc(2 * (v._id + _red_num * (u._id - _red_num)));
-        } else {
-          return Arc(-1);
-        }
-      }
-    }
-
-    typedef True FindEdgeTag;
-    typedef True FindArcTag;
-
-    Edge findEdge(Node u, Node v, Edge prev = INVALID) const {
-      return prev != INVALID ? INVALID : edge(u, v);
-    }
-
-    Arc findArc(Node s, Node t, Arc prev = INVALID) const {
-      return prev != INVALID ? INVALID : arc(s, t);
-    }
-
-  };
-
-  typedef BpGraphExtender<FullBpGraphBase> ExtendedFullBpGraphBase;
-
-  /// \ingroup graphs
-  ///
-  /// \brief An undirected full bipartite graph class.
-  ///
-  /// FullBpGraph is a simple and fast implmenetation of undirected
-  /// full bipartite graphs. It contains an edge between every
-  /// red-blue pairs of nodes, therefore the number of edges is
-  /// <tt>nr*nb</tt>.  This class is completely static and it needs
-  /// constant memory space.  Thus you can neither add nor delete
-  /// nodes or edges, however the structure can be resized using
-  /// resize().
-  ///
-  /// This type fully conforms to the \ref concepts::BpGraph "BpGraph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \sa FullGraph
-  class FullBpGraph : public ExtendedFullBpGraphBase {
-  public:
-
-    typedef ExtendedFullBpGraphBase Parent;
-
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and edges will be zero.
-    FullBpGraph() { construct(0, 0); }
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \param redNum The number of the red nodes.
-    /// \param blueNum The number of the blue nodes.
-    FullBpGraph(int redNum, int blueNum) { construct(redNum, blueNum); }
-
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
-    void resize(int redNum, int blueNum) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Edge()).clear();
-      Parent::notifier(Node()).clear();
-      Parent::notifier(BlueNode()).clear();
-      Parent::notifier(RedNode()).clear();
-      construct(redNum, blueNum);
-      Parent::notifier(RedNode()).build();
-      Parent::notifier(BlueNode()).build();
-      Parent::notifier(Node()).build();
-      Parent::notifier(Edge()).build();
-      Parent::notifier(Arc()).build();
-    }
-
-    using Parent::redNode;
-    using Parent::blueNode;
-
-    /// \brief Returns the red node with the given index.
-    ///
-    /// Returns the red node with the given index. Since this
-    /// structure is completely static, the red nodes can be indexed
-    /// with integers from the range <tt>[0..redNum()-1]</tt>.
-    /// \sa redIndex()
-    RedNode redNode(int index) const { return Parent::redNode(index); }
-
-    /// \brief Returns the index of the given red node.
-    ///
-    /// Returns the index of the given red node. Since this structure
-    /// is completely static, the red nodes can be indexed with
-    /// integers from the range <tt>[0..redNum()-1]</tt>.
-    ///
-    /// \sa operator()()
-    int index(RedNode node) const { return Parent::index(node); }
-
-    /// \brief Returns the blue node with the given index.
-    ///
-    /// Returns the blue node with the given index. Since this
-    /// structure is completely static, the blue nodes can be indexed
-    /// with integers from the range <tt>[0..blueNum()-1]</tt>.
-    /// \sa blueIndex()
-    BlueNode blueNode(int index) const { return Parent::blueNode(index); }
-
-    /// \brief Returns the index of the given blue node.
-    ///
-    /// Returns the index of the given blue node. Since this structure
-    /// is completely static, the blue nodes can be indexed with
-    /// integers from the range <tt>[0..blueNum()-1]</tt>.
-    ///
-    /// \sa operator()()
-    int index(BlueNode node) const { return Parent::index(node); }
-
-    /// \brief Returns the edge which connects the given nodes.
-    ///
-    /// Returns the edge which connects the given nodes.
-    Edge edge(const Node& u, const Node& v) const {
-      return Parent::edge(u, v);
-    }
-
-    /// \brief Returns the arc which connects the given nodes.
-    ///
-    /// Returns the arc which connects the given nodes.
-    Arc arc(const Node& u, const Node& v) const {
-      return Parent::arc(u, v);
-    }
-
-    /// \brief Number of nodes.
-    int nodeNum() const { return Parent::nodeNum(); }
-    /// \brief Number of red nodes.
-    int redNum() const { return Parent::redNum(); }
-    /// \brief Number of blue nodes.
-    int blueNum() const { return Parent::blueNum(); }
-    /// \brief Number of arcs.
-    int arcNum() const { return Parent::arcNum(); }
-    /// \brief Number of edges.
-    int edgeNum() const { return Parent::edgeNum(); }
-  };
-
 
 } //namespace lemon
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 1231)
+++ lemon/glpk.cc	(revision 1140)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -60,40 +60,4 @@
   }
 
-  int GlpkBase::_addRow(Value lo, ExprIterator b,
-                        ExprIterator e, Value up) {
-    int i = glp_add_rows(lp, 1);
-
-    if (lo == -INF) {
-      if (up == INF) {
-        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
-      } else {
-        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
-      }
-    } else {
-      if (up == INF) {
-        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
-      } else if (lo != up) {
-        glp_set_row_bnds(lp, i, GLP_DB, lo, up);
-      } else {
-        glp_set_row_bnds(lp, i, GLP_FX, lo, up);
-      }
-    }
-
-    std::vector<int> indexes;
-    std::vector<Value> values;
-
-    indexes.push_back(0);
-    values.push_back(0);
-
-    for(ExprIterator it = b; it != e; ++it) {
-      indexes.push_back(it->first);
-      values.push_back(it->second);
-    }
-
-    glp_set_mat_row(lp, i, values.size() - 1,
-                    &indexes.front(), &values.front());
-    return i;
-  }
-
   void GlpkBase::_eraseCol(int i) {
     int ca[2];
@@ -581,13 +545,4 @@
       break;
     }
-  }
-
-  void GlpkBase::_write(std::string file, std::string format) const
-  {
-    if(format == "MPS")
-      glp_write_mps(lp, GLP_MPS_FILE, 0, file.c_str());
-    else if(format == "LP")
-      glp_write_lp(lp, 0, file.c_str());
-    else throw UnsupportedFormatError(format);
   }
 
@@ -1008,5 +963,3 @@
   const char* GlpkMip::_solverName() const { return "GlpkMip"; }
 
-
-
 } //END OF NAMESPACE LEMON
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 1250)
+++ lemon/glpk.h	(revision 900)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -31,5 +31,5 @@
     class VoidPtr {
     private:
-      void *_ptr;
+      void *_ptr;      
     public:
       VoidPtr() : _ptr(0) {}
@@ -39,6 +39,6 @@
 
       template <typename T>
-      VoidPtr& operator=(T* ptr) {
-        _ptr = reinterpret_cast<void*>(ptr);
+      VoidPtr& operator=(T* ptr) { 
+        _ptr = reinterpret_cast<void*>(ptr); 
         return *this;
       }
@@ -66,5 +66,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
@@ -115,6 +114,4 @@
 
     virtual void _messageLevel(MessageLevel level);
-
-    virtual void _write(std::string file, std::string format) const;
 
   private:
@@ -127,11 +124,11 @@
       }
     };
-
+    
     static FreeEnvHelper freeEnvHelper;
 
   protected:
-
+    
     int _message_level;
-
+    
   public:
 
@@ -146,17 +143,4 @@
     ///Returns the variable identifier understood by GLPK.
     int lpxCol(Col c) const { return cols(id(c)); }
-
-#ifdef DOXYGEN
-    /// Write the problem or the solution to a file in the given format
-    
-    /// This function writes the problem or the solution
-    /// to a file in the given format.
-    /// Trying to write in an unsupported format will trigger
-    /// \ref LpBase::UnsupportedFormatError.
-    /// \param file The file path
-    /// \param format The output file format.
-    /// Supportted formats are "MPS" and "LP".
-    void write(std::string file, std::string format = "MPS") const {}
-#endif
 
   };
Index: lemon/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 1254)
+++ lemon/gomory_hu.h	(revision 643)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * 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-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,5 +28,5 @@
 
 /// \ingroup min_cut
-/// \file
+/// \file 
 /// \brief Gomory-Hu cut tree in graphs.
 
@@ -39,5 +39,5 @@
   /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   /// may contain edges which are not in the original graph. It has the
-  /// property that the minimum capacity edge of the path between two nodes
+  /// property that the minimum capacity edge of the path between two nodes 
   /// in this tree has the same weight as the minimum cut in the graph
   /// between these nodes. Moreover the components obtained by removing
@@ -45,7 +45,7 @@
   /// Therefore once this tree is computed, the minimum cut between any pair
   /// of nodes can easily be obtained.
-  ///
+  /// 
   /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
-  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{m})\f$ overall
+  /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
   /// time complexity. It calculates a rooted Gomory-Hu tree.
   /// The structure of the tree and the edge weights can be
@@ -61,8 +61,8 @@
 #ifdef DOXYGEN
   template <typename GR,
-            typename CAP>
+	    typename CAP>
 #else
   template <typename GR,
-            typename CAP = typename GR::template EdgeMap<int> >
+	    typename CAP = typename GR::template EdgeMap<int> >
 #endif
   class GomoryHu {
@@ -75,5 +75,5 @@
     /// The value type of capacities
     typedef typename Capacity::Value Value;
-
+    
   private:
 
@@ -90,11 +90,11 @@
     void createStructures() {
       if (!_pred) {
-        _pred = new typename Graph::template NodeMap<Node>(_graph);
+	_pred = new typename Graph::template NodeMap<Node>(_graph);
       }
       if (!_weight) {
-        _weight = new typename Graph::template NodeMap<Value>(_graph);
+	_weight = new typename Graph::template NodeMap<Value>(_graph);
       }
       if (!_order) {
-        _order = new typename Graph::template NodeMap<int>(_graph);
+	_order = new typename Graph::template NodeMap<int>(_graph);
       }
     }
@@ -102,14 +102,14 @@
     void destroyStructures() {
       if (_pred) {
-        delete _pred;
+	delete _pred;
       }
       if (_weight) {
-        delete _weight;
+	delete _weight;
       }
       if (_order) {
-        delete _order;
-      }
-    }
-
+	delete _order;
+      }
+    }
+  
   public:
 
@@ -119,7 +119,7 @@
     /// \param graph The undirected graph the algorithm runs on.
     /// \param capacity The edge capacity map.
-    GomoryHu(const Graph& graph, const Capacity& capacity)
+    GomoryHu(const Graph& graph, const Capacity& capacity) 
       : _graph(graph), _capacity(capacity),
-        _pred(0), _weight(0), _order(0)
+	_pred(0), _weight(0), _order(0) 
     {
       checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
@@ -135,5 +135,5 @@
 
   private:
-
+  
     // Initialize the internal data structures
     void init() {
@@ -146,5 +146,5 @@
       }
       (*_pred)[_root] = INVALID;
-      (*_weight)[_root] = std::numeric_limits<Value>::max();
+      (*_weight)[_root] = std::numeric_limits<Value>::max(); 
     }
 
@@ -155,25 +155,25 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (n == _root) continue;
-
-        Node pn = (*_pred)[n];
-        fa.source(n);
-        fa.target(pn);
-
-        fa.runMinCut();
-
-        (*_weight)[n] = fa.flowValue();
-
-        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
-          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
-            (*_pred)[nn] = n;
-          }
-        }
-        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
-          (*_pred)[n] = (*_pred)[pn];
-          (*_pred)[pn] = n;
-          (*_weight)[n] = (*_weight)[pn];
-          (*_weight)[pn] = fa.flowValue();
-        }
+	if (n == _root) continue;
+
+	Node pn = (*_pred)[n];
+	fa.source(n);
+	fa.target(pn);
+
+	fa.runMinCut();
+
+	(*_weight)[n] = fa.flowValue();
+
+	for (NodeIt nn(_graph); nn != INVALID; ++nn) {
+	  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
+	    (*_pred)[nn] = n;
+	  }
+	}
+	if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
+	  (*_pred)[n] = (*_pred)[pn];
+	  (*_pred)[pn] = n;
+	  (*_weight)[n] = (*_weight)[pn];
+	  (*_weight)[pn] = fa.flowValue();
+	}
       }
 
@@ -182,14 +182,14 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        std::vector<Node> st;
-        Node nn = n;
-        while ((*_order)[nn] == -1) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          (*_order)[st.back()] = index++;
-          st.pop_back();
-        }
+	std::vector<Node> st;
+	Node nn = n;
+	while ((*_order)[nn] == -1) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  (*_order)[st.back()] = index++;
+	  st.pop_back();
+	}
       }
     }
@@ -198,5 +198,5 @@
 
     ///\name Execution Control
-
+ 
     ///@{
 
@@ -208,5 +208,5 @@
       start();
     }
-
+    
     /// @}
 
@@ -233,5 +233,5 @@
     /// Gomory-Hu tree.
     ///
-    /// This function returns the weight of the predecessor edge of the
+    /// This function returns the weight of the predecessor edge of the 
     /// given node in the Gomory-Hu tree.
     /// If \c node is the root of the tree, the result is undefined.
@@ -255,5 +255,5 @@
     ///
     /// This function returns the minimum cut value between the nodes
-    /// \c s and \c t.
+    /// \c s and \c t. 
     /// It finds the nearest common ancestor of the given nodes in the
     /// Gomory-Hu tree and calculates the minimum weight edge on the
@@ -264,13 +264,13 @@
       Node sn = s, tn = t;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
-          sn = (*_pred)[sn];
-        }
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) value = (*_weight)[tn];
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) value = (*_weight)[sn];
+	  sn = (*_pred)[sn];
+	}
       }
       return value;
@@ -295,7 +295,9 @@
     /// \pre \ref run() must be called before using this function.
     template <typename CutMap>
-    Value minCutMap(const Node& s,
+    Value minCutMap(const Node& s, ///< 
                     const Node& t,
+                    ///< 
                     CutMap& cutMap
+                    ///< 
                     ) const {
       Node sn = s, tn = t;
@@ -303,21 +305,21 @@
       Node rn = INVALID;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) {
-            rn = tn;
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) {
+	    rn = tn;
             s_root = false;
-            value = (*_weight)[tn];
-          }
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) {
-            rn = sn;
+	    value = (*_weight)[tn];
+	  }
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) {
+	    rn = sn;
             s_root = true;
-            value = (*_weight)[sn];
-          }
-          sn = (*_pred)[sn];
-        }
+	    value = (*_weight)[sn];
+	  }
+	  sn = (*_pred)[sn];
+	}
       }
 
@@ -330,16 +332,16 @@
       std::vector<Node> st;
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        st.clear();
+	st.clear();
         Node nn = n;
-        while (!reached[nn]) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          cutMap.set(st.back(), cutMap[nn]);
-          st.pop_back();
-        }
-      }
-
+	while (!reached[nn]) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  cutMap.set(st.back(), cutMap[nn]);
+	  st.pop_back();
+	}
+      }
+      
       return value;
     }
@@ -350,5 +352,5 @@
 
     /// Iterate on the nodes of a minimum cut
-
+    
     /// This iterator class lists the nodes of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -358,8 +360,8 @@
     /// \c t.
     /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int cnt=0;
-    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
+    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
     /// \endcode
     class MinCutNodeIt
@@ -393,5 +395,5 @@
                    /// \endcode
                    /// does not necessarily give the same set of nodes.
-                   /// However, it is ensured that
+                   /// However it is ensured that
                    /// \code
                    /// MinCutNodeIt(gomory, s, t, true);
@@ -443,9 +445,9 @@
       }
     };
-
+    
     friend class MinCutEdgeIt;
-
+    
     /// Iterate on the edges of a minimum cut
-
+    
     /// This iterator class lists the edges of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -455,8 +457,8 @@
     /// \c t.
     /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int value=0;
-    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
+    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
     ///   value+=capacities[e];
     /// \endcode
@@ -480,5 +482,5 @@
           }
       }
-
+      
     public:
       /// Constructor
@@ -549,5 +551,5 @@
       }
       /// Postfix incrementation
-
+      
       /// Postfix incrementation.
       ///
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 1159)
+++ lemon/graph_to_eps.h	(revision 1247)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -143,5 +143,5 @@
   ///\param gr  Reference to the graph to be printed.
   ///\param ost Reference to the output stream.
-  ///By default, it is <tt>std::cout</tt>.
+  ///By default it is <tt>std::cout</tt>.
   ///\param pros If it is \c true, then the \c ostream referenced by \c os
   ///will be explicitly deallocated by the destructor.
@@ -223,5 +223,5 @@
   using T::_copyright;
 
-  using typename T::NodeTextColorType;
+  using T::NodeTextColorType;
   using T::CUST_COL;
   using T::DIST_COL;
@@ -513,5 +513,5 @@
   ///Turn on/off pre-scaling
 
-  ///By default, graphToEps() rescales the whole image in order to avoid
+  ///By default graphToEps() rescales the whole image in order to avoid
   ///very big or very small bounding boxes.
   ///
@@ -1115,5 +1115,5 @@
 ///\param g Reference to the graph to be printed.
 ///\param os Reference to the output stream.
-///By default, it is <tt>std::cout</tt>.
+///By default it is <tt>std::cout</tt>.
 ///
 ///This function also has a lot of
@@ -1127,5 +1127,5 @@
 ///\endcode
 ///
-///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file.
+///For more detailed examples see the \ref graph_to_eps_demo.cc demo file.
 ///
 ///\warning Don't forget to put the \ref GraphToEps::run() "run()"
Index: lemon/greedy_tsp.h
===================================================================
--- lemon/greedy_tsp.h	(revision 1250)
+++ 	(revision )
@@ -1,251 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_GREEDY_TSP_H
-#define LEMON_GREEDY_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Greedy algorithm for symmetric TSP
-
-#include <vector>
-#include <algorithm>
-#include <lemon/full_graph.h>
-#include <lemon/unionfind.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief Greedy algorithm for symmetric TSP.
-  ///
-  /// GreedyTsp implements the greedy heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This algorithm is quite similar to the \ref NearestNeighborTsp
-  /// "nearest neighbor" heuristic, but it maintains a set of disjoint paths.
-  /// At each step, the shortest possible edge is added to these paths
-  /// as long as it does not create a cycle of less than n edges and it does
-  /// not increase the degree of any node above two.
-  ///
-  /// This method runs in O(n<sup>2</sup>) time.
-  /// It quickly finds a relatively short tour for most TSP instances,
-  /// but it could also yield a really bad (or even the worst) solution
-  /// in special cases.
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class GreedyTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      Cost _sum;
-      std::vector<Node> _path;
-      
-    private:
-    
-      // Functor class to compare edges by their costs
-      class EdgeComp {
-      private:
-        const CostMap &_cost;
-
-      public:
-        EdgeComp(const CostMap &cost) : _cost(cost) {}
-
-        bool operator()(const Edge &a, const Edge &b) const {
-          return _cost[a] < _cost[b];
-        }
-      };
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      GreedyTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-
-        std::vector<int> plist;
-        plist.resize(_gr.nodeNum()*2, -1);
-
-        std::vector<Edge> sorted_edges;
-        sorted_edges.reserve(_gr.edgeNum());
-        for (EdgeIt e(_gr); e != INVALID; ++e)
-          sorted_edges.push_back(e);
-        std::sort(sorted_edges.begin(), sorted_edges.end(), EdgeComp(_cost));
-
-        FullGraph::NodeMap<int> item_int_map(_gr);
-        UnionFind<FullGraph::NodeMap<int> > union_find(item_int_map);
-        for (NodeIt n(_gr); n != INVALID; ++n)
-          union_find.insert(n);
-
-        FullGraph::NodeMap<int> degree(_gr, 0);
-
-        int nodesNum = 0, i = 0;
-        while (nodesNum != _gr.nodeNum()-1) {
-          Edge e = sorted_edges[i++];
-          Node u = _gr.u(e),
-               v = _gr.v(e);
-
-          if (degree[u] <= 1 && degree[v] <= 1) {
-            if (union_find.join(u, v)) {
-              const int uid = _gr.id(u),
-                        vid = _gr.id(v);
-
-              plist[uid*2 + degree[u]] = vid;
-              plist[vid*2 + degree[v]] = uid;
-
-              ++degree[u];
-              ++degree[v];
-              ++nodesNum;
-            }
-          }
-        }
-
-        for (int i=0, n=-1; i<_gr.nodeNum()*2; ++i) {
-          if (plist[i] == -1) {
-            if (n==-1) {
-              n = i;
-            } else {
-              plist[n] = i/2;
-              plist[i] = n/2;
-              break;
-            }
-          }
-        }
-
-        for (int i=0, next=0, last=-1; i!=_gr.nodeNum(); ++i) {
-          _path.push_back(_gr.nodeFromId(next));
-          if (plist[2*next] != last) {
-            last = next;
-            next = plist[2*next];
-          } else {
-            last = next;
-            next = plist[2*next+1];
-          }
-        }
-
-        _sum = _cost[_gr.edge(_path.back(), _path.front())];
-        for (int i = 0; i < int(_path.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_path[i], _path[i+1])];
-        }
-
-        return _sum;
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-
-      /// @}
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/grid_graph.h
===================================================================
--- lemon/grid_graph.h	(revision 834)
+++ lemon/grid_graph.h	(revision 664)
@@ -471,19 +471,15 @@
   /// \brief Grid graph class
   ///
-  /// GridGraph implements a special graph type. The nodes of the
-  /// graph can be indexed by two integer values \c (i,j) where \c i is
-  /// in the range <tt>[0..width()-1]</tt> and j is in the range
-  /// <tt>[0..height()-1]</tt>. Two nodes are connected in the graph if
-  /// the indices differ exactly on one position and the difference is
-  /// also exactly one. The nodes of the graph can be obtained by position
-  /// using the \c operator()() function and the indices of the nodes can
-  /// be obtained using \c pos(), \c col() and \c row() members. The outgoing
+  /// This class implements a special graph type. The nodes of the
+  /// graph can be indexed by two integer \c (i,j) value where \c i is
+  /// in the \c [0..width()-1] range and j is in the \c
+  /// [0..height()-1] range.  Two nodes are connected in the graph if
+  /// the indexes differ exactly on one position and exactly one is
+  /// the difference. The nodes of the graph can be indexed by position
+  /// with the \c operator()() function. The positions of the nodes can be
+  /// get with \c pos(), \c col() and \c row() members. The outgoing
   /// arcs can be retrieved with the \c right(), \c up(), \c left()
   /// and \c down() functions, where the bottom-left corner is the
   /// origin.
-  ///
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however
-  /// the structure can be resized using resize().
   ///
   /// \image html grid_graph.png
@@ -501,9 +497,6 @@
   ///\endcode
   ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
+  /// This graph type fully conforms to the \ref concepts::Graph
+  /// "Graph concept".
   class GridGraph : public ExtendedGridGraphBase {
     typedef ExtendedGridGraphBase Parent;
@@ -511,9 +504,7 @@
   public:
 
-    /// \brief Map to get the indices of the nodes as \ref dim2::Point
-    /// "dim2::Point<int>".
-    ///
-    /// Map to get the indices of the nodes as \ref dim2::Point
-    /// "dim2::Point<int>".
+    /// \brief Map to get the indices of the nodes as dim2::Point<int>.
+    ///
+    /// Map to get the indices of the nodes as dim2::Point<int>.
     class IndexMap {
     public:
@@ -524,7 +515,11 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       IndexMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.pos(key);
@@ -546,7 +541,11 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       ColMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.col(key);
@@ -568,7 +567,11 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       RowMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.row(key);
@@ -581,12 +584,13 @@
     /// \brief Constructor
     ///
-    /// Construct a grid graph with the given size.
+    /// Construct a grid graph with given size.
     GridGraph(int width, int height) { construct(width, height); }
 
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
+    /// \brief Resize the graph
+    ///
+    /// Resize the graph. The function will fully destroy and rebuild
+    /// the graph.  This cause that the maps of the graph will
+    /// reallocated automatically and the previous values will be
+    /// lost.
     void resize(int width, int height) {
       Parent::notifier(Arc()).clear();
@@ -606,5 +610,5 @@
     }
 
-    /// \brief The column index of the node.
+    /// \brief Gives back the column index of the node.
     ///
     /// Gives back the column index of the node.
@@ -613,5 +617,5 @@
     }
 
-    /// \brief The row index of the node.
+    /// \brief Gives back the row index of the node.
     ///
     /// Gives back the row index of the node.
@@ -620,5 +624,5 @@
     }
 
-    /// \brief The position of the node.
+    /// \brief Gives back the position of the node.
     ///
     /// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair.
@@ -627,5 +631,5 @@
     }
 
-    /// \brief The number of the columns.
+    /// \brief Gives back the number of the columns.
     ///
     /// Gives back the number of the columns.
@@ -634,5 +638,5 @@
     }
 
-    /// \brief The number of the rows.
+    /// \brief Gives back the number of the rows.
     ///
     /// Gives back the number of the rows.
@@ -641,5 +645,5 @@
     }
 
-    /// \brief The arc goes right from the node.
+    /// \brief Gives back the arc goes right from the node.
     ///
     /// Gives back the arc goes right from the node. If there is not
@@ -649,5 +653,5 @@
     }
 
-    /// \brief The arc goes left from the node.
+    /// \brief Gives back the arc goes left from the node.
     ///
     /// Gives back the arc goes left from the node. If there is not
@@ -657,5 +661,5 @@
     }
 
-    /// \brief The arc goes up from the node.
+    /// \brief Gives back the arc goes up from the node.
     ///
     /// Gives back the arc goes up from the node. If there is not
@@ -665,5 +669,5 @@
     }
 
-    /// \brief The arc goes down from the node.
+    /// \brief Gives back the arc goes down from the node.
     ///
     /// Gives back the arc goes down from the node. If there is not
Index: lemon/grosso_locatelli_pullan_mc.h
===================================================================
--- lemon/grosso_locatelli_pullan_mc.h	(revision 1221)
+++ 	(revision )
@@ -1,840 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_GROSSO_LOCATELLI_PULLAN_MC_H
-#define LEMON_GROSSO_LOCATELLI_PULLAN_MC_H
-
-/// \ingroup approx_algs
-///
-/// \file
-/// \brief The iterated local search algorithm of Grosso, Locatelli, and Pullan
-/// for the maximum clique problem
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/random.h>
-
-namespace lemon {
-
-  /// \addtogroup approx_algs
-  /// @{
-
-  /// \brief Implementation of the iterated local search algorithm of Grosso,
-  /// Locatelli, and Pullan for the maximum clique problem
-  ///
-  /// \ref GrossoLocatelliPullanMc implements the iterated local search
-  /// algorithm of Grosso, Locatelli, and Pullan for solving the \e maximum
-  /// \e clique \e problem \cite grosso08maxclique.
-  /// It is to find the largest complete subgraph (\e clique) in an
-  /// undirected graph, i.e., the largest set of nodes where each
-  /// pair of nodes is connected.
-  ///
-  /// This class provides a simple but highly efficient and robust heuristic
-  /// method that quickly finds a quite large clique, but not necessarily the
-  /// largest one.
-  /// The algorithm performs a certain number of iterations to find several
-  /// cliques and selects the largest one among them. Various limits can be
-  /// specified to control the running time and the effectiveness of the
-  /// search process.
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  ///
-  /// \note %GrossoLocatelliPullanMc provides three different node selection
-  /// rules, from which the most powerful one is used by default.
-  /// For more information, see \ref SelectionRule.
-  template <typename GR>
-  class GrossoLocatelliPullanMc
-  {
-  public:
-
-    /// \brief Constants for specifying the node selection rule.
-    ///
-    /// Enum type containing constants for specifying the node selection rule
-    /// for the \ref run() function.
-    ///
-    /// During the algorithm, nodes are selected for addition to the current
-    /// clique according to the applied rule.
-    /// In general, the PENALTY_BASED rule turned out to be the most powerful
-    /// and the most robust, thus it is the default option.
-    /// However, another selection rule can be specified using the \ref run()
-    /// function with the proper parameter.
-    enum SelectionRule {
-
-      /// A node is selected randomly without any evaluation at each step.
-      RANDOM,
-
-      /// A node of maximum degree is selected randomly at each step.
-      DEGREE_BASED,
-
-      /// A node of minimum penalty is selected randomly at each step.
-      /// The node penalties are updated adaptively after each stage of the
-      /// search process.
-      PENALTY_BASED
-    };
-
-    /// \brief Constants for the causes of search termination.
-    ///
-    /// Enum type containing constants for the different causes of search
-    /// termination. The \ref run() function returns one of these values.
-    enum TerminationCause {
-
-      /// The iteration count limit is reached.
-      ITERATION_LIMIT,
-
-      /// The step count limit is reached.
-      STEP_LIMIT,
-
-      /// The clique size limit is reached.
-      SIZE_LIMIT
-    };
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<char> BoolVector;
-    typedef std::vector<BoolVector> BoolMatrix;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-    // The underlying graph
-    const GR &_graph;
-    IntNodeMap _id;
-
-    // Internal matrix representation of the graph
-    BoolMatrix _gr;
-    int _n;
-    
-    // Search options
-    bool _delta_based_restart;
-    int _restart_delta_limit;
- 
-    // Search limits
-    int _iteration_limit;
-    int _step_limit;
-    int _size_limit;
-
-    // The current clique
-    BoolVector _clique;
-    int _size;
-
-    // The best clique found so far
-    BoolVector _best_clique;
-    int _best_size;
-
-    // The "distances" of the nodes from the current clique.
-    // _delta[u] is the number of nodes in the clique that are
-    // not connected with u.
-    IntVector _delta;
-
-    // The current tabu set
-    BoolVector _tabu;
-
-    // Random number generator
-    Random _rnd;
-
-  private:
-
-    // Implementation of the RANDOM node selection rule.
-    class RandomSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-
-    public:
-
-      // Constructor
-      RandomSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n)
-      {}
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i]) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i]) return i;
-        }
-        return -1;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i;
-        }
-        return -1;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0) return i;
-        }
-        return -1;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class RandomSelectionRule
-
-
-    // Implementation of the DEGREE_BASED node selection rule.
-    class DegreeBasedSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-      IntVector _deg;
-
-    public:
-
-      // Constructor
-      DegreeBasedSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n), _deg(_n)
-      {
-        for (int i = 0; i != _n; i++) {
-          int d = 0;
-          BoolVector &row = mc._gr[i];
-          for (int j = 0; j != _n; j++) {
-            if (row[j]) d++;
-          }
-          _deg[i] = d;
-        }
-      }
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class DegreeBasedSelectionRule
-
-
-    // Implementation of the PENALTY_BASED node selection rule.
-    class PenaltyBasedSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-      IntVector _penalty;
-
-    public:
-
-      // Constructor
-      PenaltyBasedSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n), _penalty(_n, 0)
-      {}
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class PenaltyBasedSelectionRule
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// The global \ref rnd "random number generator instance" is used
-    /// during the algorithm.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    GrossoLocatelliPullanMc(const GR& graph) :
-      _graph(graph), _id(_graph), _rnd(rnd)
-    {
-      initOptions();
-    }
-
-    /// \brief Constructor with random seed.
-    ///
-    /// Constructor with random seed.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    /// \param seed Seed value for the internal random number generator
-    /// that is used during the algorithm.
-    GrossoLocatelliPullanMc(const GR& graph, int seed) :
-      _graph(graph), _id(_graph), _rnd(seed)
-    {
-      initOptions();
-    }
-
-    /// \brief Constructor with random number generator.
-    ///
-    /// Constructor with random number generator.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    /// \param random A random number generator that is used during the
-    /// algorithm.
-    GrossoLocatelliPullanMc(const GR& graph, const Random& random) :
-      _graph(graph), _id(_graph), _rnd(random)
-    {
-      initOptions();
-    }
-
-    /// \name Execution Control
-    /// The \ref run() function can be used to execute the algorithm.\n
-    /// The functions \ref iterationLimit(int), \ref stepLimit(int), and 
-    /// \ref sizeLimit(int) can be used to specify various limits for the
-    /// search process.
-    
-    /// @{
-    
-    /// \brief Sets the maximum number of iterations.
-    ///
-    /// This function sets the maximum number of iterations.
-    /// Each iteration of the algorithm finds a maximal clique (but not
-    /// necessarily the largest one) by performing several search steps
-    /// (node selections).
-    ///
-    /// This limit controls the running time and the success of the
-    /// algorithm. For larger values, the algorithm runs slower, but it more
-    /// likely finds larger cliques. For smaller values, the algorithm is
-    /// faster but probably gives worse results.
-    /// 
-    /// The default value is \c 1000.
-    /// \c -1 means that number of iterations is not limited.
-    ///
-    /// \warning You should specify a reasonable limit for the number of
-    /// iterations and/or the number of search steps.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa stepLimit(int)
-    /// \sa sizeLimit(int)
-    GrossoLocatelliPullanMc& iterationLimit(int limit) {
-      _iteration_limit = limit;
-      return *this;
-    }
-    
-    /// \brief Sets the maximum number of search steps.
-    ///
-    /// This function sets the maximum number of elementary search steps.
-    /// Each iteration of the algorithm finds a maximal clique (but not
-    /// necessarily the largest one) by performing several search steps
-    /// (node selections).
-    ///
-    /// This limit controls the running time and the success of the
-    /// algorithm. For larger values, the algorithm runs slower, but it more
-    /// likely finds larger cliques. For smaller values, the algorithm is
-    /// faster but probably gives worse results.
-    /// 
-    /// The default value is \c -1, which means that number of steps
-    /// is not limited explicitly. However, the number of iterations is
-    /// limited and each iteration performs a finite number of search steps.
-    ///
-    /// \warning You should specify a reasonable limit for the number of
-    /// iterations and/or the number of search steps.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa iterationLimit(int)
-    /// \sa sizeLimit(int)
-    GrossoLocatelliPullanMc& stepLimit(int limit) {
-      _step_limit = limit;
-      return *this;
-    }
-    
-    /// \brief Sets the desired clique size.
-    ///
-    /// This function sets the desired clique size that serves as a search
-    /// limit. If a clique of this size (or a larger one) is found, then the
-    /// algorithm terminates.
-    /// 
-    /// This function is especially useful if you know an exact upper bound
-    /// for the size of the cliques in the graph or if any clique above 
-    /// a certain size limit is sufficient for your application.
-    /// 
-    /// The default value is \c -1, which means that the size limit is set to
-    /// the number of nodes in the graph.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa iterationLimit(int)
-    /// \sa stepLimit(int)
-    GrossoLocatelliPullanMc& sizeLimit(int limit) {
-      _size_limit = limit;
-      return *this;
-    }
-    
-    /// \brief The maximum number of iterations.
-    ///
-    /// This function gives back the maximum number of iterations.
-    /// \c -1 means that no limit is specified.
-    ///
-    /// \sa iterationLimit(int)
-    int iterationLimit() const {
-      return _iteration_limit;
-    }
-    
-    /// \brief The maximum number of search steps.
-    ///
-    /// This function gives back the maximum number of search steps.
-    /// \c -1 means that no limit is specified.
-    ///
-    /// \sa stepLimit(int)
-    int stepLimit() const {
-      return _step_limit;
-    }
-    
-    /// \brief The desired clique size.
-    ///
-    /// This function gives back the desired clique size that serves as a
-    /// search limit. \c -1 means that this limit is set to the number of
-    /// nodes in the graph.
-    ///
-    /// \sa sizeLimit(int)
-    int sizeLimit() const {
-      return _size_limit;
-    }
-
-    /// \brief Runs the algorithm.
-    ///
-    /// This function runs the algorithm. If one of the specified limits
-    /// is reached, the search process terminates.
-    ///
-    /// \param rule The node selection rule. For more information, see
-    /// \ref SelectionRule.
-    ///
-    /// \return The termination cause of the search. For more information,
-    /// see \ref TerminationCause.
-    TerminationCause run(SelectionRule rule = PENALTY_BASED)
-    {
-      init();
-      switch (rule) {
-        case RANDOM:
-          return start<RandomSelectionRule>();
-        case DEGREE_BASED:
-          return start<DegreeBasedSelectionRule>();
-        default:
-          return start<PenaltyBasedSelectionRule>();
-      }
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these functions.\n
-    /// The run() function must be called before using them. 
-
-    /// @{
-
-    /// \brief The size of the found clique
-    ///
-    /// This function returns the size of the found clique.
-    ///
-    /// \pre run() must be called before using this function.
-    int cliqueSize() const {
-      return _best_size;
-    }
-
-    /// \brief Gives back the found clique in a \c bool node map
-    ///
-    /// This function gives back the characteristic vector of the found
-    /// clique in the given node map.
-    /// It must be a \ref concepts::WriteMap "writable" node map with
-    /// \c bool (or convertible) value type.
-    ///
-    /// \pre run() must be called before using this function.
-    template <typename CliqueMap>
-    void cliqueMap(CliqueMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map[n] = static_cast<bool>(_best_clique[_id[n]]);
-      }
-    }
-
-    /// \brief Iterator to list the nodes of the found clique
-    ///
-    /// This iterator class lists the nodes of the found clique.
-    /// Before using it, you must allocate a GrossoLocatelliPullanMc instance
-    /// and call its \ref GrossoLocatelliPullanMc::run() "run()" method.
-    ///
-    /// The following example prints out the IDs of the nodes in the found
-    /// clique.
-    /// \code
-    ///   GrossoLocatelliPullanMc<Graph> mc(g);
-    ///   mc.run();
-    ///   for (GrossoLocatelliPullanMc<Graph>::CliqueNodeIt n(mc);
-    ///        n != INVALID; ++n)
-    ///   {
-    ///     std::cout << g.id(n) << std::endl;
-    ///   }
-    /// \endcode
-    class CliqueNodeIt
-    {
-    private:
-      NodeIt _it;
-      BoolNodeMap _map;
-
-    public:
-
-      /// Constructor
-
-      /// Constructor.
-      /// \param mc The algorithm instance.
-      CliqueNodeIt(const GrossoLocatelliPullanMc &mc)
-       : _map(mc._graph)
-      {
-        mc.cliqueMap(_map);
-        for (_it = NodeIt(mc._graph); _it != INVALID && !_map[_it]; ++_it) ;
-      }
-
-      /// Conversion to \c Node
-      operator Node() const { return _it; }
-
-      bool operator==(Invalid) const { return _it == INVALID; }
-      bool operator!=(Invalid) const { return _it != INVALID; }
-
-      /// Next node
-      CliqueNodeIt &operator++() {
-        for (++_it; _it != INVALID && !_map[_it]; ++_it) ;
-        return *this;
-      }
-
-      /// Postfix incrementation
-
-      /// Postfix incrementation.
-      ///
-      /// \warning This incrementation returns a \c Node, not a
-      /// \c CliqueNodeIt as one may expect.
-      typename GR::Node operator++(int) {
-        Node n=*this;
-        ++(*this);
-        return n;
-      }
-
-    };
-
-    /// @}
-
-  private:
-  
-    // Initialize search options and limits
-    void initOptions() {
-      // Search options
-      _delta_based_restart = true;
-      _restart_delta_limit = 4;
-     
-      // Search limits
-      _iteration_limit = 1000;
-      _step_limit = -1;             // this is disabled by default
-      _size_limit = -1;             // this is disabled by default
-    }
-
-    // Adds a node to the current clique
-    void addCliqueNode(int u) {
-      if (_clique[u]) return;
-      _clique[u] = true;
-      _size++;
-      BoolVector &row = _gr[u];
-      for (int i = 0; i != _n; i++) {
-        if (!row[i]) _delta[i]++;
-      }
-    }
-
-    // Removes a node from the current clique
-    void delCliqueNode(int u) {
-      if (!_clique[u]) return;
-      _clique[u] = false;
-      _size--;
-      BoolVector &row = _gr[u];
-      for (int i = 0; i != _n; i++) {
-        if (!row[i]) _delta[i]--;
-      }
-    }
-
-    // Initialize data structures
-    void init() {
-      _n = countNodes(_graph);
-      int ui = 0;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        _id[u] = ui++;
-      }
-      _gr.clear();
-      _gr.resize(_n, BoolVector(_n, false));
-      ui = 0;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        for (IncEdgeIt e(_graph, u); e != INVALID; ++e) {
-          int vi = _id[_graph.runningNode(e)];
-          _gr[ui][vi] = true;
-          _gr[vi][ui] = true;
-        }
-        ++ui;
-      }
-
-      _clique.clear();
-      _clique.resize(_n, false);
-      _size = 0;
-      _best_clique.clear();
-      _best_clique.resize(_n, false);
-      _best_size = 0;
-      _delta.clear();
-      _delta.resize(_n, 0);
-      _tabu.clear();
-      _tabu.resize(_n, false);
-    }
-
-    // Executes the algorithm
-    template <typename SelectionRuleImpl>
-    TerminationCause start() {
-      if (_n == 0) return SIZE_LIMIT;
-      if (_n == 1) {
-        _best_clique[0] = true;
-        _best_size = 1;
-        return SIZE_LIMIT;
-      }
-
-      // Iterated local search algorithm
-      const int max_size = _size_limit >= 0 ? _size_limit : _n;
-      const int max_restart = _iteration_limit >= 0 ?
-        _iteration_limit : std::numeric_limits<int>::max();
-      const int max_select = _step_limit >= 0 ?
-        _step_limit : std::numeric_limits<int>::max();
-
-      SelectionRuleImpl sel_method(*this);
-      int select = 0, restart = 0;
-      IntVector restart_nodes;
-      while (select < max_select && restart < max_restart) {
-
-        // Perturbation/restart
-        restart++;
-        if (_delta_based_restart) {
-          restart_nodes.clear();
-          for (int i = 0; i != _n; i++) {
-            if (_delta[i] >= _restart_delta_limit)
-              restart_nodes.push_back(i);
-          }
-        }
-        int rs_node = -1;
-        if (restart_nodes.size() > 0) {
-          rs_node = restart_nodes[_rnd[restart_nodes.size()]];
-        } else {
-          rs_node = _rnd[_n];
-        }
-        BoolVector &row = _gr[rs_node];
-        for (int i = 0; i != _n; i++) {
-          if (_clique[i] && !row[i]) delCliqueNode(i);
-        }
-        addCliqueNode(rs_node);
-
-        // Local search
-        _tabu.clear();
-        _tabu.resize(_n, false);
-        bool tabu_empty = true;
-        int max_swap = _size;
-        while (select < max_select) {
-          select++;
-          int u;
-          if ((u = sel_method.nextFeasibleAddNode()) != -1) {
-            // Feasible add move
-            addCliqueNode(u);
-            if (tabu_empty) max_swap = _size;
-          }
-          else if ((u = sel_method.nextFeasibleSwapNode()) != -1) {
-            // Feasible swap move
-            int v = -1;
-            BoolVector &row = _gr[u];
-            for (int i = 0; i != _n; i++) {
-              if (_clique[i] && !row[i]) {
-                v = i;
-                break;
-              }
-            }
-            addCliqueNode(u);
-            delCliqueNode(v);
-            _tabu[v] = true;
-            tabu_empty = false;
-            if (--max_swap <= 0) break;
-          }
-          else if ((u = sel_method.nextAddNode()) != -1) {
-            // Non-feasible add move
-            addCliqueNode(u);
-          }
-          else break;
-        }
-        if (_size > _best_size) {
-          _best_clique = _clique;
-          _best_size = _size;
-          if (_best_size >= max_size) return SIZE_LIMIT;
-        }
-        sel_method.update();
-      }
-
-      return (restart >= max_restart ? ITERATION_LIMIT : STEP_LIMIT);
-    }
-
-  }; //class GrossoLocatelliPullanMc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_GROSSO_LOCATELLI_PULLAN_MC_H
Index: lemon/hao_orlin.h
===================================================================
--- lemon/hao_orlin.h	(revision 1019)
+++ lemon/hao_orlin.h	(revision 644)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -32,5 +32,5 @@
 /// \brief Implementation of the Hao-Orlin algorithm.
 ///
-/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
+/// Implementation of the Hao-Orlin algorithm for finding a minimum cut 
 /// in a digraph.
 
@@ -42,5 +42,5 @@
   ///
   /// This class implements the Hao-Orlin algorithm for finding a minimum
-  /// value cut in a directed graph \f$D=(V,A)\f$.
+  /// value cut in a directed graph \f$D=(V,A)\f$. 
   /// It takes a fixed node \f$ source \in V \f$ and
   /// consists of two phases: in the first phase it determines a
@@ -54,10 +54,10 @@
   /// preflow push-relabel algorithm. Our implementation calculates
   /// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the
-  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. A notable
-  /// use of this algorithm is testing network reliability.
+  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. The
+  /// purpose of such algorithm is e.g. testing network reliability.
   ///
   /// For an undirected graph you can run just the first phase of the
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
-  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
+  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ 
   /// time. It is implemented in the NagamochiIbaraki algorithm class.
   ///
@@ -77,5 +77,5 @@
   class HaoOrlin {
   public:
-
+   
     /// The digraph type of the algorithm
     typedef GR Digraph;
@@ -164,21 +164,4 @@
         delete _flow;
       }
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    HaoOrlin& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
     }
 
@@ -865,5 +848,5 @@
     ///
     /// This function initializes the internal data structures. It creates
-    /// the maps and some bucket structures for the algorithm.
+    /// the maps and some bucket structures for the algorithm. 
     /// The given node is used as the source node for the push-relabel
     /// algorithm.
@@ -913,6 +896,4 @@
     /// source-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \in X \f$ and minimal outgoing capacity).
-    /// It updates the stored cut if (and only if) the newly found one
-    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
@@ -927,6 +908,4 @@
     /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \notin X \f$ and minimal outgoing capacity).
-    /// It updates the stored cut if (and only if) the newly found one
-    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
@@ -938,6 +917,6 @@
     /// \brief Run the algorithm.
     ///
-    /// This function runs the algorithm. It chooses source node,
-    /// then calls \ref init(), \ref calculateOut()
+    /// This function runs the algorithm. It finds nodes \c source and
+    /// \c target arbitrarily and then calls \ref init(), \ref calculateOut()
     /// and \ref calculateIn().
     void run() {
@@ -949,7 +928,7 @@
     /// \brief Run the algorithm.
     ///
-    /// This function runs the algorithm. It calls \ref init(),
-    /// \ref calculateOut() and \ref calculateIn() with the given
-    /// source node.
+    /// This function runs the algorithm. It uses the given \c source node, 
+    /// finds a proper \c target node and then calls the \ref init(),
+    /// \ref calculateOut() and \ref calculateIn().
     void run(const Node& s) {
       init(s);
@@ -963,5 +942,5 @@
     /// The result of the %HaoOrlin algorithm
     /// can be obtained using these functions.\n
-    /// \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// should be called before using them.
 
@@ -970,9 +949,7 @@
     /// \brief Return the value of the minimum cut.
     ///
-    /// This function returns the value of the best cut found by the
-    /// previously called \ref run(), \ref calculateOut() or \ref
-    /// calculateIn().
-    ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// This function returns the value of the minimum cut.
+    ///
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     Value minCutValue() const {
@@ -983,11 +960,7 @@
     /// \brief Return a minimum cut.
     ///
-    /// This function gives the best cut found by the
-    /// previously called \ref run(), \ref calculateOut() or \ref
-    /// calculateIn().
-    ///
-    /// It sets \c cutMap to the characteristic vector of the found
-    /// minimum value cut - a non-empty set \f$ X\subsetneq V \f$
-    /// of minimum outgoing capacity (i.e. \c cutMap will be \c true exactly
+    /// This function sets \c cutMap to the characteristic vector of a
+    /// minimum value cut: it will give a non-empty set \f$ X\subsetneq V \f$
+    /// with minimal outgoing capacity (i.e. \c cutMap will be \c true exactly
     /// for the nodes of \f$ X \f$).
     ///
@@ -997,5 +970,5 @@
     /// \return The value of the minimum cut.
     ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     template <typename CutMap>
Index: lemon/hartmann_orlin_mmc.h
===================================================================
--- lemon/hartmann_orlin_mmc.h	(revision 1254)
+++ 	(revision )
@@ -1,654 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_HARTMANN_ORLIN_MMC_H
-#define LEMON_HARTMANN_ORLIN_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Hartmann-Orlin's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of HartmannOrlinMmc class.
-  ///
-  /// Default traits class of HartmannOrlinMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct HartmannOrlinMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct HartmannOrlinMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of the Hartmann-Orlin algorithm for finding
-  /// a minimum mean cycle.
-  ///
-  /// This class implements the Hartmann-Orlin algorithm for finding
-  /// a directed cycle of minimum mean cost in a digraph
-  /// \cite hartmann93finding, \cite dasdan98minmeancycle.
-  /// This method is based on \ref KarpMmc "Karp"'s original algorithm, but
-  /// applies an early termination scheme. It makes the algorithm
-  /// significantly faster for some problem instances, but slower for others.
-  /// The algorithm runs in time O(nm) and uses space O(n<sup>2</sup>+m).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref HartmannOrlinMmcDefaultTraits
-  /// "HartmannOrlinMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = HartmannOrlinMmcDefaultTraits<GR, CM> >
-#endif
-  class HartmannOrlinMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref lemon::HartmannOrlinMmcDefaultTraits
-    /// "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// \brief The
-    /// \ref lemon::HartmannOrlinMmcDefaultTraits "traits class"
-    /// of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeCost dist;
-      Arc pred;
-      PathData(LargeCost d, Arc p = INVALID) :
-        dist(d), pred(p) {}
-    };
-
-    typedef typename Digraph::template NodeMap<std::vector<PathData> >
-      PathDataNodeMap;
-
-  private:
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
-
-    // Data for the found cycles
-    bool _curr_found, _best_found;
-    LargeCost _curr_cost, _best_cost;
-    int _curr_size, _best_size;
-    Node _curr_node, _best_node;
-    int _curr_level, _best_level;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Node map for storing path data
-    PathDataNodeMap _data;
-    // The processed nodes in the last round
-    std::vector<Node> _process;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public HartmannOrlinMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef HartmannOrlinMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    template <typename T>
-    struct SetPath
-      : public HartmannOrlinMmc<GR, CM, SetPathTraits<T> > {
-      typedef HartmannOrlinMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    HartmannOrlinMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    HartmannOrlinMmc( const Digraph &digraph,
-                      const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph),
-      _best_found(false), _best_cost(0), _best_size(1),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~HartmannOrlinMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), a local \ref Path "path" structure
-    /// will be allocated. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addFront()
-    /// "addFront()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    HartmannOrlinMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    HartmannOrlinMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findCycleMean() {
-      // Initialization and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        if (!initComponent(comp)) continue;
-        processRounds();
-
-        // Update the best cycle (global minimum mean cycle)
-        if ( _curr_found && (!_best_found ||
-             _curr_cost * _best_size < _best_cost * _curr_size) ) {
-          _best_found = true;
-          _best_cost = _curr_cost;
-          _best_size = _curr_size;
-          _best_node = _curr_node;
-          _best_level = _curr_level;
-        }
-      }
-      return _best_found;
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (!_best_found) return false;
-      IntNodeMap reached(_gr, -1);
-      int r = _best_level + 1;
-      Node u = _best_node;
-      while (reached[u] < 0) {
-        reached[u] = --r;
-        u = _gr.source(_data[u][r].pred);
-      }
-      r = reached[u];
-      Arc e = _data[u][r].pred;
-      _cycle_path->addFront(e);
-      _best_cost = _cost[e];
-      _best_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _best_cost += _cost[e];
-        ++_best_size;
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_best_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_cost) / _best_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialization
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _cycle_path->clear();
-      _best_found = false;
-      _best_cost = 0;
-      _best_size = 1;
-      _cycle_path->clear();
-      for (NodeIt u(_gr); u != INVALID; ++u)
-        _data[u].clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _out_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            _out_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Initialize path data for the current component
-    bool initComponent(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      int n = _nodes->size();
-      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < n; ++i) {
-        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
-      }
-      return true;
-    }
-
-    // Process all rounds of computing path data for the current component.
-    // _data[v][k] is the cost of a shortest directed walk from the root
-    // node to node v containing exactly k arcs.
-    void processRounds() {
-      Node start = (*_nodes)[0];
-      _data[start][0] = PathData(0);
-      _process.clear();
-      _process.push_back(start);
-
-      int k, n = _nodes->size();
-      int next_check = 4;
-      bool terminate = false;
-      for (k = 1; k <= n && int(_process.size()) < n && !terminate; ++k) {
-        processNextBuildRound(k);
-        if (k == next_check || k == n) {
-          terminate = checkTermination(k);
-          next_check = next_check * 3 / 2;
-        }
-      }
-      for ( ; k <= n && !terminate; ++k) {
-        processNextFullRound(k);
-        if (k == next_check || k == n) {
-          terminate = checkTermination(k);
-          next_check = next_check * 3 / 2;
-        }
-      }
-    }
-
-    // Process one round and rebuild _process
-    void processNextBuildRound(int k) {
-      std::vector<Node> next;
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        u = _process[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            if (_data[v][k].dist == INF) next.push_back(v);
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-      _process.swap(next);
-    }
-
-    // Process one round using _nodes instead of _process
-    void processNextFullRound(int k) {
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-    }
-
-    // Check early termination
-    bool checkTermination(int k) {
-      typedef std::pair<int, int> Pair;
-      typename GR::template NodeMap<Pair> level(_gr, Pair(-1, 0));
-      typename GR::template NodeMap<LargeCost> pi(_gr);
-      int n = _nodes->size();
-      LargeCost cost;
-      int size;
-      Node u;
-
-      // Search for cycles that are already found
-      _curr_found = false;
-      for (int i = 0; i < n; ++i) {
-        u = (*_nodes)[i];
-        if (_data[u][k].dist == INF) continue;
-        for (int j = k; j >= 0; --j) {
-          if (level[u].first == i && level[u].second > 0) {
-            // A cycle is found
-            cost = _data[u][level[u].second].dist - _data[u][j].dist;
-            size = level[u].second - j;
-            if (!_curr_found || cost * _curr_size < _curr_cost * size) {
-              _curr_cost = cost;
-              _curr_size = size;
-              _curr_node = u;
-              _curr_level = level[u].second;
-              _curr_found = true;
-            }
-          }
-          level[u] = Pair(i, j);
-          if (j != 0) {
-            u = _gr.source(_data[u][j].pred);
-          }
-        }
-      }
-
-      // If at least one cycle is found, check the optimality condition
-      LargeCost d;
-      if (_curr_found && k < n) {
-        // Find node potentials
-        for (int i = 0; i < n; ++i) {
-          u = (*_nodes)[i];
-          pi[u] = INF;
-          for (int j = 0; j <= k; ++j) {
-            if (_data[u][j].dist < INF) {
-              d = _data[u][j].dist * _curr_size - j * _curr_cost;
-              if (_tolerance.less(d, pi[u])) pi[u] = d;
-            }
-          }
-        }
-
-        // Check the optimality condition for all arcs
-        bool done = true;
-        for (ArcIt a(_gr); a != INVALID; ++a) {
-          if (_tolerance.less(_cost[a] * _curr_size - _curr_cost,
-                              pi[_gr.target(a)] - pi[_gr.source(a)]) ) {
-            done = false;
-            break;
-          }
-        }
-        return done;
-      }
-      return (k == n);
-    }
-
-  }; //class HartmannOrlinMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HARTMANN_ORLIN_MMC_H
Index: lemon/howard_mmc.h
===================================================================
--- lemon/howard_mmc.h	(revision 1250)
+++ 	(revision )
@@ -1,650 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_HOWARD_MMC_H
-#define LEMON_HOWARD_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Howard's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of HowardMmc class.
-  ///
-  /// Default traits class of HowardMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct HowardMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct HowardMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of Howard's algorithm for finding a minimum
-  /// mean cycle.
-  ///
-  /// This class implements Howard's policy iteration algorithm for finding
-  /// a directed cycle of minimum mean cost in a digraph
-  /// \cite dasdan98minmeancycle, \cite dasdan04experimental.
-  /// This class provides the most efficient algorithm for the
-  /// minimum mean cycle problem, though the best known theoretical
-  /// bound on its running time is exponential.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref HowardMmcDefaultTraits
-  /// "HowardMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = HowardMmcDefaultTraits<GR, CM> >
-#endif
-  class HowardMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref lemon::HowardMmcDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref lemon::HowardMmcDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-    /// \brief Constants for the causes of search termination.
-    ///
-    /// Enum type containing constants for the different causes of search
-    /// termination. The \ref findCycleMean() function returns one of
-    /// these values.
-    enum TerminationCause {
-      
-      /// No directed cycle can be found in the digraph.
-      NO_CYCLE = 0,
-    
-      /// Optimal solution (minimum cycle mean) is found.
-      OPTIMAL = 1,
-
-      /// The iteration count limit is reached.
-      ITERATION_LIMIT
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for the found cycles
-    bool _curr_found, _best_found;
-    LargeCost _curr_cost, _best_cost;
-    int _curr_size, _best_size;
-    Node _curr_node, _best_node;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Internal data used by the algorithm
-    typename Digraph::template NodeMap<Arc> _policy;
-    typename Digraph::template NodeMap<bool> _reached;
-    typename Digraph::template NodeMap<int> _level;
-    typename Digraph::template NodeMap<LargeCost> _dist;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;
-
-    // Queue used for BFS search
-    std::vector<Node> _queue;
-    int _qfront, _qback;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public HowardMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef HowardMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    template <typename T>
-    struct SetPath
-      : public HowardMmc<GR, CM, SetPathTraits<T> > {
-      typedef HowardMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    HowardMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    HowardMmc( const Digraph &digraph,
-               const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _best_found(false),
-      _best_cost(0), _best_size(1), _cycle_path(NULL), _local_path(false),
-      _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph),
-      _comp(digraph), _in_arcs(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~HowardMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), a local \ref Path "path" structure
-    /// will be allocated. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addBack()
-    /// "addBack()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    HowardMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    HowardMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean (or an upper bound).
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph (or an upper bound for it).
-    ///
-    /// By default, the function finds the exact minimum cycle mean,
-    /// but an optional limit can also be specified for the number of
-    /// iterations performed during the search process.
-    /// The return value indicates if the optimal solution is found
-    /// or the iteration limit is reached. In the latter case, an
-    /// approximate solution is provided, which corresponds to a directed
-    /// cycle whose mean cost is relatively small, but not necessarily
-    /// minimal.
-    ///
-    /// \param limit  The maximum allowed number of iterations during
-    /// the search process. Its default value implies that the algorithm 
-    /// runs until it finds the exact optimal solution.
-    ///
-    /// \return The termination cause of the search process.
-    /// For more information, see \ref TerminationCause. 
-    TerminationCause findCycleMean(int limit = std::numeric_limits<int>::max()) {
-      // Initialize and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      int iter_count = 0;
-      bool iter_limit_reached = false;
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        // Find the minimum mean cycle in the current component
-        if (!buildPolicyGraph(comp)) continue;
-        while (true) {
-          if (++iter_count > limit) {
-            iter_limit_reached = true;
-            break;
-          }
-          findPolicyCycle();
-          if (!computeNodeDistances()) break;
-        }
-
-        // Update the best cycle (global minimum mean cycle)
-        if ( _curr_found && (!_best_found ||
-             _curr_cost * _best_size < _best_cost * _curr_size) ) {
-          _best_found = true;
-          _best_cost = _curr_cost;
-          _best_size = _curr_size;
-          _best_node = _curr_node;
-        }
-        
-        if (iter_limit_reached) break;
-      }
-
-      if (iter_limit_reached) {
-        return ITERATION_LIMIT;
-      } else {
-        return _best_found ? OPTIMAL : NO_CYCLE;
-      }
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (!_best_found) return false;
-      _cycle_path->addBack(_policy[_best_node]);
-      for ( Node v = _best_node;
-            (v = _gr.target(_policy[v])) != _best_node; ) {
-        _cycle_path->addBack(_policy[v]);
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_best_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_cost) / _best_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialize
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _queue.resize(countNodes(_gr));
-      _best_found = false;
-      _best_cost = 0;
-      _best_size = 1;
-      _cycle_path->clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _in_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _in_arcs[n].clear();
-          for (InArcIt a(_gr, n); a != INVALID; ++a) {
-            _in_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _in_arcs[n].clear();
-          for (InArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.source(a)] == k) _in_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Build the policy graph in the given strongly connected component
-    // (the out-degree of every node is 1)
-    bool buildPolicyGraph(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      if (_nodes->size() < 1 ||
-          (_nodes->size() == 1 && _in_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _dist[(*_nodes)[i]] = INF;
-      }
-      Node u, v;
-      Arc e;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        v = (*_nodes)[i];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (_cost[e] < _dist[u]) {
-            _dist[u] = _cost[e];
-            _policy[u] = e;
-          }
-        }
-      }
-      return true;
-    }
-
-    // Find the minimum mean cycle in the policy graph
-    void findPolicyCycle() {
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _level[(*_nodes)[i]] = -1;
-      }
-      LargeCost ccost;
-      int csize;
-      Node u, v;
-      _curr_found = false;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        if (_level[u] >= 0) continue;
-        for (; _level[u] < 0; u = _gr.target(_policy[u])) {
-          _level[u] = i;
-        }
-        if (_level[u] == i) {
-          // A cycle is found
-          ccost = _cost[_policy[u]];
-          csize = 1;
-          for (v = u; (v = _gr.target(_policy[v])) != u; ) {
-            ccost += _cost[_policy[v]];
-            ++csize;
-          }
-          if ( !_curr_found ||
-               (ccost * _curr_size < _curr_cost * csize) ) {
-            _curr_found = true;
-            _curr_cost = ccost;
-            _curr_size = csize;
-            _curr_node = u;
-          }
-        }
-      }
-    }
-
-    // Contract the policy graph and compute node distances
-    bool computeNodeDistances() {
-      // Find the component of the main cycle and compute node distances
-      // using reverse BFS
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _reached[(*_nodes)[i]] = false;
-      }
-      _qfront = _qback = 0;
-      _queue[0] = _curr_node;
-      _reached[_curr_node] = true;
-      _dist[_curr_node] = 0;
-      Node u, v;
-      Arc e;
-      while (_qfront <= _qback) {
-        v = _queue[_qfront++];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (_policy[u] == e && !_reached[u]) {
-            _reached[u] = true;
-            _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-            _queue[++_qback] = u;
-          }
-        }
-      }
-
-      // Connect all other nodes to this component and compute node
-      // distances using reverse BFS
-      _qfront = 0;
-      while (_qback < int(_nodes->size())-1) {
-        v = _queue[_qfront++];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (!_reached[u]) {
-            _reached[u] = true;
-            _policy[u] = e;
-            _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-            _queue[++_qback] = u;
-          }
-        }
-      }
-
-      // Improve node distances
-      bool improved = false;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        v = (*_nodes)[i];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          LargeCost delta = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-          if (_tolerance.less(delta, _dist[u])) {
-            _dist[u] = delta;
-            _policy[u] = e;
-            improved = true;
-          }
-        }
-      }
-      return improved;
-    }
-
-  }; //class HowardMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HOWARD_MMC_H
Index: lemon/hypercube_graph.h
===================================================================
--- lemon/hypercube_graph.h	(revision 835)
+++ lemon/hypercube_graph.h	(revision 664)
@@ -263,5 +263,5 @@
     }
 
-    static int index(Node node) {
+    int index(Node node) const {
       return node._id;
     }
@@ -283,21 +283,15 @@
   /// \brief Hypercube graph class
   ///
-  /// HypercubeGraph implements a special graph type. The nodes of the
-  /// graph are indexed with integers having at most \c dim binary digits.
+  /// This class implements a special graph type. The nodes of the graph
+  /// are indiced with integers with at most \c dim binary digits.
   /// Two nodes are connected in the graph if and only if their indices
   /// differ only on one position in the binary form.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however,
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
   ///
   /// \note The type of the indices is chosen to \c int for efficiency
   /// reasons. Thus the maximum dimension of this implementation is 26
   /// (assuming that the size of \c int is 32 bit).
+  ///
+  /// This graph type fully conforms to the \ref concepts::Graph
+  /// "Graph concept".
   class HypercubeGraph : public ExtendedHypercubeGraphBase {
     typedef ExtendedHypercubeGraphBase Parent;
@@ -309,19 +303,4 @@
     /// Constructs a hypercube graph with \c dim dimensions.
     HypercubeGraph(int dim) { construct(dim); }
-
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
-    void resize(int dim) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Edge()).clear();
-      Parent::notifier(Node()).clear();
-      construct(dim);
-      Parent::notifier(Node()).build();
-      Parent::notifier(Edge()).build();
-      Parent::notifier(Arc()).build();
-    }
 
     /// \brief The number of dimensions.
@@ -342,5 +321,5 @@
     ///
     /// Gives back the dimension id of the given edge.
-    /// It is in the range <tt>[0..dim-1]</tt>.
+    /// It is in the [0..dim-1] range.
     int dimension(Edge edge) const {
       return Parent::dimension(edge);
@@ -350,5 +329,5 @@
     ///
     /// Gives back the dimension id of the given arc.
-    /// It is in the range <tt>[0..dim-1]</tt>.
+    /// It is in the [0..dim-1] range.
     int dimension(Arc arc) const {
       return Parent::dimension(arc);
@@ -359,5 +338,5 @@
     /// Gives back the index of the given node.
     /// The lower bits of the integer describes the node.
-    static int index(Node node) {
+    int index(Node node) const {
       return Parent::index(node);
     }
Index: lemon/insertion_tsp.h
===================================================================
--- lemon/insertion_tsp.h	(revision 1250)
+++ 	(revision )
@@ -1,533 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_INSERTION_TSP_H
-#define LEMON_INSERTION_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Insertion algorithm for symmetric TSP
-
-#include <vector>
-#include <functional>
-#include <lemon/full_graph.h>
-#include <lemon/maps.h>
-#include <lemon/random.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief Insertion algorithm for symmetric TSP.
-  ///
-  /// InsertionTsp implements the insertion heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This is a fast and effective tour construction method that has
-  /// many variants.
-  /// It starts with a subtour containing a few nodes of the graph and it
-  /// iteratively inserts the other nodes into this subtour according to a
-  /// certain node selection rule.
-  ///
-  /// This method is among the fastest TSP algorithms, and it typically
-  /// provides quite good solutions (usually much better than
-  /// \ref NearestNeighborTsp and \ref GreedyTsp).
-  ///
-  /// InsertionTsp implements four different node selection rules,
-  /// from which the most effective one (\e farthest \e node \e selection)
-  /// is used by default.
-  /// With this choice, the algorithm runs in O(n<sup>2</sup>) time.
-  /// For more information, see \ref SelectionRule.
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class InsertionTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      std::vector<Node> _notused;
-      std::vector<Node> _tour;
-      Cost _sum;
-
-    public:
-
-      /// \brief Constants for specifying the node selection rule.
-      ///
-      /// Enum type containing constants for specifying the node selection
-      /// rule for the \ref run() function.
-      ///
-      /// During the algorithm, nodes are selected for addition to the current
-      /// subtour according to the applied rule.
-      /// The FARTHEST method is one of the fastest selection rules, and
-      /// it is typically the most effective, thus it is the default
-      /// option. The RANDOM rule usually gives slightly worse results,
-      /// but it is more robust.
-      ///
-      /// The desired selection rule can be specified as a parameter of the
-      /// \ref run() function.
-      enum SelectionRule {
-
-        /// An unvisited node having minimum distance from the current
-        /// subtour is selected at each step.
-        /// The algorithm runs in O(n<sup>2</sup>) time using this
-        /// selection rule.
-        NEAREST,
-
-        /// An unvisited node having maximum distance from the current
-        /// subtour is selected at each step.
-        /// The algorithm runs in O(n<sup>2</sup>) time using this
-        /// selection rule.
-        FARTHEST,
-
-        /// An unvisited node whose insertion results in the least
-        /// increase of the subtour's total cost is selected at each step.
-        /// The algorithm runs in O(n<sup>3</sup>) time using this
-        /// selection rule, but in most cases, it is almost as fast as
-        /// with other rules.
-        CHEAPEST,
-
-        /// An unvisited node is selected randomly without any evaluation
-        /// at each step.
-        /// The global \ref rnd "random number generator instance" is used.
-        /// You can seed it before executing the algorithm, if you
-        /// would like to.
-        /// The algorithm runs in O(n<sup>2</sup>) time using this
-        /// selection rule.
-        RANDOM
-      };
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      InsertionTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \param rule The node selection rule. For more information, see
-      /// \ref SelectionRule.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run(SelectionRule rule = FARTHEST) {
-        _tour.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _tour.push_back(_gr(0));
-          return _sum = 0;
-        }
-
-        switch (rule) {
-          case NEAREST:
-            init(true);
-            start<ComparingSelection<std::less<Cost> >,
-                  DefaultInsertion>();
-            break;
-          case FARTHEST:
-            init(false);
-            start<ComparingSelection<std::greater<Cost> >,
-                  DefaultInsertion>();
-            break;
-          case CHEAPEST:
-            init(true);
-            start<CheapestSelection, CheapestInsertion>();
-            break;
-          case RANDOM:
-            init(true);
-            start<RandomSelection, DefaultInsertion>();
-            break;
-        }
-        return _sum;
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _tour;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_tour.begin(), _tour.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_tour.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_tour[i], _tour[i+1]));
-        }
-        if (int(_tour.size()) >= 2) {
-          path.addBack(_gr.arc(_tour.back(), _tour.front()));
-        }
-      }
-
-      /// @}
-
-    private:
-
-      // Initializes the algorithm
-      void init(bool min) {
-        Edge min_edge = min ? mapMin(_gr, _cost) : mapMax(_gr, _cost);
-
-        _tour.clear();
-        _tour.push_back(_gr.u(min_edge));
-        _tour.push_back(_gr.v(min_edge));
-
-        _notused.clear();
-        for (NodeIt n(_gr); n!=INVALID; ++n) {
-          if (n != _gr.u(min_edge) && n != _gr.v(min_edge)) {
-            _notused.push_back(n);
-          }
-        }
-
-        _sum = _cost[min_edge] * 2;
-      }
-
-      // Executes the algorithm
-      template <class SelectionFunctor, class InsertionFunctor>
-      void start() {
-        SelectionFunctor selectNode(_gr, _cost, _tour, _notused);
-        InsertionFunctor insertNode(_gr, _cost, _tour, _sum);
-
-        for (int i=0; i<_gr.nodeNum()-2; ++i) {
-          insertNode.insert(selectNode.select());
-        }
-
-        _sum = _cost[_gr.edge(_tour.back(), _tour.front())];
-        for (int i = 0; i < int(_tour.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_tour[i], _tour[i+1])];
-        }
-      }
-
-
-      // Implementation of the nearest and farthest selection rule
-      template <typename Comparator>
-      class ComparingSelection {
-        public:
-          ComparingSelection(const FullGraph &gr, const CostMap &cost,
-                  std::vector<Node> &tour, std::vector<Node> &notused)
-            : _gr(gr), _cost(cost), _tour(tour), _notused(notused),
-              _dist(gr, 0), _compare()
-          {
-            // Compute initial distances for the unused nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost min_dist = _cost[_gr.edge(u, _tour[0])];
-              for (unsigned int j=1; j<_tour.size(); ++j) {
-                Cost curr = _cost[_gr.edge(u, _tour[j])];
-                if (curr < min_dist) {
-                  min_dist = curr;
-                }
-              }
-              _dist[u] = min_dist;
-            }
-          }
-
-          Node select() {
-
-            // Select an used node with minimum distance
-            Cost ins_dist = 0;
-            int ins_node = -1;
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Cost curr = _dist[_notused[i]];
-              if (_compare(curr, ins_dist) || ins_node == -1) {
-                ins_dist = curr;
-                ins_node = i;
-              }
-            }
-
-            // Remove the selected node from the unused vector
-            Node sn = _notused[ins_node];
-            _notused[ins_node] = _notused.back();
-            _notused.pop_back();
-
-            // Update the distances of the remaining nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost nc = _cost[_gr.edge(sn, u)];
-              if (nc < _dist[u]) {
-                _dist[u] = nc;
-              }
-            }
-
-            return sn;
-          }
-
-        private:
-          const FullGraph &_gr;
-          const CostMap &_cost;
-          std::vector<Node> &_tour;
-          std::vector<Node> &_notused;
-          FullGraph::NodeMap<Cost> _dist;
-          Comparator _compare;
-      };
-
-      // Implementation of the cheapest selection rule
-      class CheapestSelection {
-        private:
-          Cost costDiff(Node u, Node v, Node w) const {
-            return
-              _cost[_gr.edge(u, w)] +
-              _cost[_gr.edge(v, w)] -
-              _cost[_gr.edge(u, v)];
-          }
-
-        public:
-          CheapestSelection(const FullGraph &gr, const CostMap &cost,
-                            std::vector<Node> &tour, std::vector<Node> &notused)
-            : _gr(gr), _cost(cost), _tour(tour), _notused(notused),
-              _ins_cost(gr, 0), _ins_pos(gr, -1)
-          {
-            // Compute insertion cost and position for the unused nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost min_cost = costDiff(_tour.back(), _tour.front(), u);
-              int min_pos = 0;              
-              for (unsigned int j=1; j<_tour.size(); ++j) {
-                Cost curr_cost = costDiff(_tour[j-1], _tour[j], u);
-                if (curr_cost < min_cost) {
-                  min_cost = curr_cost;
-                  min_pos = j;
-                }
-              }
-              _ins_cost[u] = min_cost;
-              _ins_pos[u] = min_pos;
-            }
-          }
-
-          Cost select() {
-
-            // Select an used node with minimum insertion cost
-            Cost min_cost = 0;
-            int min_node = -1;
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Cost curr_cost = _ins_cost[_notused[i]];
-              if (curr_cost < min_cost || min_node == -1) {
-                min_cost = curr_cost;
-                min_node = i;
-              }
-            }
-
-            // Remove the selected node from the unused vector
-            Node sn = _notused[min_node];
-            _notused[min_node] = _notused.back();
-            _notused.pop_back();
-            
-            // Insert the selected node into the tour
-            const int ipos = _ins_pos[sn];
-            _tour.insert(_tour.begin() + ipos, sn);
-
-            // Update the insertion cost and position of the remaining nodes
-            for (unsigned int i=0; i<_notused.size(); ++i) {
-              Node u = _notused[i];
-              Cost curr_cost = _ins_cost[u];
-              int curr_pos = _ins_pos[u];
-
-              int ipos_prev = ipos == 0 ? _tour.size()-1 : ipos-1;
-              int ipos_next = ipos == int(_tour.size())-1 ? 0 : ipos+1;
-              Cost nc1 = costDiff(_tour[ipos_prev], _tour[ipos], u);
-              Cost nc2 = costDiff(_tour[ipos], _tour[ipos_next], u);
-              
-              if (nc1 <= curr_cost || nc2 <= curr_cost) {
-                // A new position is better than the old one
-                if (nc1 <= nc2) {
-                  curr_cost = nc1;
-                  curr_pos = ipos;
-                } else {
-                  curr_cost = nc2;
-                  curr_pos = ipos_next;
-                }
-              }
-              else {
-                if (curr_pos == ipos) {
-                  // The minimum should be found again
-                  curr_cost = costDiff(_tour.back(), _tour.front(), u);
-                  curr_pos = 0;              
-                  for (unsigned int j=1; j<_tour.size(); ++j) {
-                    Cost tmp_cost = costDiff(_tour[j-1], _tour[j], u);
-                    if (tmp_cost < curr_cost) {
-                      curr_cost = tmp_cost;
-                      curr_pos = j;
-                    }
-                  }
-                }
-                else if (curr_pos > ipos) {
-                  ++curr_pos;
-                }
-              }
-              
-              _ins_cost[u] = curr_cost;
-              _ins_pos[u] = curr_pos;
-            }
-
-            return min_cost;
-          }
-
-        private:
-          const FullGraph &_gr;
-          const CostMap &_cost;
-          std::vector<Node> &_tour;
-          std::vector<Node> &_notused;
-          FullGraph::NodeMap<Cost> _ins_cost;
-          FullGraph::NodeMap<int> _ins_pos;
-      };
-
-      // Implementation of the random selection rule
-      class RandomSelection {
-        public:
-          RandomSelection(const FullGraph &, const CostMap &,
-                          std::vector<Node> &, std::vector<Node> &notused)
-            : _notused(notused) {}
-
-          Node select() const {
-            const int index = rnd[_notused.size()];
-            Node n = _notused[index];
-            _notused[index] = _notused.back();
-            _notused.pop_back();
-            return n;
-          }
-
-        private:
-          std::vector<Node> &_notused;
-      };
-
-
-      // Implementation of the default insertion method
-      class DefaultInsertion {
-        private:
-          Cost costDiff(Node u, Node v, Node w) const {
-            return
-              _cost[_gr.edge(u, w)] +
-              _cost[_gr.edge(v, w)] -
-              _cost[_gr.edge(u, v)];
-          }
-
-        public:
-          DefaultInsertion(const FullGraph &gr, const CostMap &cost,
-                           std::vector<Node> &tour, Cost &total_cost) :
-            _gr(gr), _cost(cost), _tour(tour), _total(total_cost) {}
-
-          void insert(Node n) const {
-            int min = 0;
-            Cost min_val =
-              costDiff(_tour.front(), _tour.back(), n);
-
-            for (unsigned int i=1; i<_tour.size(); ++i) {
-              Cost tmp = costDiff(_tour[i-1], _tour[i], n);
-              if (tmp < min_val) {
-                min = i;
-                min_val = tmp;
-              }
-            }
-
-            _tour.insert(_tour.begin()+min, n);
-            _total += min_val;
-          }
-
-        private:
-          const FullGraph &_gr;
-          const CostMap &_cost;
-          std::vector<Node> &_tour;
-          Cost &_total;
-      };
-
-      // Implementation of a special insertion method for the cheapest
-      // selection rule
-      class CheapestInsertion {
-        TEMPLATE_GRAPH_TYPEDEFS(FullGraph);
-        public:
-          CheapestInsertion(const FullGraph &, const CostMap &,
-                            std::vector<Node> &, Cost &total_cost) :
-            _total(total_cost) {}
-
-          void insert(Cost diff) const {
-            _total += diff;
-          }
-
-        private:
-          Cost &_total;
-      };
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/karp_mmc.h
===================================================================
--- lemon/karp_mmc.h	(revision 1254)
+++ 	(revision )
@@ -1,590 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_KARP_MMC_H
-#define LEMON_KARP_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Karp's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of KarpMmc class.
-  ///
-  /// Default traits class of KarpMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct KarpMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct KarpMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of Karp's algorithm for finding a minimum
-  /// mean cycle.
-  ///
-  /// This class implements Karp's algorithm for finding a directed
-  /// cycle of minimum mean cost in a digraph
-  /// \cite karp78characterization, \cite dasdan98minmeancycle.
-  /// It runs in time O(nm) and uses space O(n<sup>2</sup>+m).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref KarpMmcDefaultTraits
-  /// "KarpMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = KarpMmcDefaultTraits<GR, CM> >
-#endif
-  class KarpMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref lemon::KarpMmcDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref lemon::KarpMmcDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeCost dist;
-      Arc pred;
-      PathData(LargeCost d, Arc p = INVALID) :
-        dist(d), pred(p) {}
-    };
-
-    typedef typename Digraph::template NodeMap<std::vector<PathData> >
-      PathDataNodeMap;
-
-  private:
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
-
-    // Data for the found cycle
-    LargeCost _cycle_cost;
-    int _cycle_size;
-    Node _cycle_node;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Node map for storing path data
-    PathDataNodeMap _data;
-    // The processed nodes in the last round
-    std::vector<Node> _process;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public KarpMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef KarpMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    template <typename T>
-    struct SetPath
-      : public KarpMmc<GR, CM, SetPathTraits<T> > {
-      typedef KarpMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    KarpMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    KarpMmc( const Digraph &digraph,
-             const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph),
-      _cycle_cost(0), _cycle_size(1), _cycle_node(INVALID),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~KarpMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), a local \ref Path "path" structure
-    /// will be allocated. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addFront()
-    /// "addFront()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    KarpMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    KarpMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findCycleMean() {
-      // Initialization and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        if (!initComponent(comp)) continue;
-        processRounds();
-        updateMinMean();
-      }
-      return (_cycle_node != INVALID);
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (_cycle_node == INVALID) return false;
-      IntNodeMap reached(_gr, -1);
-      int r = _data[_cycle_node].size();
-      Node u = _cycle_node;
-      while (reached[u] < 0) {
-        reached[u] = --r;
-        u = _gr.source(_data[u][r].pred);
-      }
-      r = reached[u];
-      Arc e = _data[u][r].pred;
-      _cycle_path->addFront(e);
-      _cycle_cost = _cost[e];
-      _cycle_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _cycle_cost += _cost[e];
-        ++_cycle_size;
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_cycle_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _cycle_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_cycle_cost) / _cycle_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialization
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _cycle_path->clear();
-      _cycle_cost = 0;
-      _cycle_size = 1;
-      _cycle_node = INVALID;
-      for (NodeIt u(_gr); u != INVALID; ++u)
-        _data[u].clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _out_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            _out_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Initialize path data for the current component
-    bool initComponent(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      int n = _nodes->size();
-      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < n; ++i) {
-        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
-      }
-      return true;
-    }
-
-    // Process all rounds of computing path data for the current component.
-    // _data[v][k] is the cost of a shortest directed walk from the root
-    // node to node v containing exactly k arcs.
-    void processRounds() {
-      Node start = (*_nodes)[0];
-      _data[start][0] = PathData(0);
-      _process.clear();
-      _process.push_back(start);
-
-      int k, n = _nodes->size();
-      for (k = 1; k <= n && int(_process.size()) < n; ++k) {
-        processNextBuildRound(k);
-      }
-      for ( ; k <= n; ++k) {
-        processNextFullRound(k);
-      }
-    }
-
-    // Process one round and rebuild _process
-    void processNextBuildRound(int k) {
-      std::vector<Node> next;
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        u = _process[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            if (_data[v][k].dist == INF) next.push_back(v);
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-      _process.swap(next);
-    }
-
-    // Process one round using _nodes instead of _process
-    void processNextFullRound(int k) {
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-    }
-
-    // Update the minimum cycle mean
-    void updateMinMean() {
-      int n = _nodes->size();
-      for (int i = 0; i < n; ++i) {
-        Node u = (*_nodes)[i];
-        if (_data[u][n].dist == INF) continue;
-        LargeCost cost, max_cost = 0;
-        int size, max_size = 1;
-        bool found_curr = false;
-        for (int k = 0; k < n; ++k) {
-          if (_data[u][k].dist == INF) continue;
-          cost = _data[u][n].dist - _data[u][k].dist;
-          size = n - k;
-          if (!found_curr || cost * max_size > max_cost * size) {
-            found_curr = true;
-            max_cost = cost;
-            max_size = size;
-          }
-        }
-        if ( found_curr && (_cycle_node == INVALID ||
-             max_cost * _cycle_size < _cycle_cost * max_size) ) {
-          _cycle_cost = max_cost;
-          _cycle_size = max_size;
-          _cycle_node = u;
-        }
-      }
-    }
-
-  }; //class KarpMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_KARP_MMC_H
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 1025)
+++ lemon/kruskal.h	(revision 631)
@@ -31,4 +31,7 @@
 ///\file
 ///\brief Kruskal's algorithm to compute a minimum cost spanning tree
+///
+///Kruskal's algorithm to compute a minimum cost spanning tree.
+///
 
 namespace lemon {
Index: lemon/lemon.pc.cmake
===================================================================
--- lemon/lemon.pc.cmake	(revision 1012)
+++ lemon/lemon.pc.cmake	(revision 1012)
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@/bin
+libdir=@CMAKE_INSTALL_PREFIX@/lib
+includedir=@CMAKE_INSTALL_PREFIX@/include
+
+Name: @PROJECT_NAME@
+Description: Library for Efficient Modeling and Optimization in Networks
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
+Cflags: -I${includedir}
Index: lemon/lemon.pc.in
===================================================================
--- lemon/lemon.pc.in	(revision 1133)
+++ lemon/lemon.pc.in	(revision 705)
@@ -1,10 +1,10 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=@CMAKE_INSTALL_PREFIX@/bin
-libdir=@CMAKE_INSTALL_PREFIX@/lib
-includedir=@CMAKE_INSTALL_PREFIX@/include
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
 
-Name: @PROJECT_NAME@
+Name: @PACKAGE_NAME@
 Description: Library for Efficient Modeling and Optimization in Networks
-Version: @PROJECT_VERSION@
+Version: @PACKAGE_VERSION@
 Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
 Cflags: -I${includedir}
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 1250)
+++ lemon/lgf_reader.h	(revision 1069)
@@ -155,14 +155,14 @@
     };
 
-    template <typename Value,
-              typename Map = std::map<std::string, Value> >
+    template <typename Value>
     struct MapLookUpConverter {
-      const Map& _map;
-
-      MapLookUpConverter(const Map& map)
+      const std::map<std::string, Value>& _map;
+
+      MapLookUpConverter(const std::map<std::string, Value>& map)
         : _map(map) {}
 
       Value operator()(const std::string& str) {
-        typename Map::const_iterator it = _map.find(str);
+        typename std::map<std::string, Value>::const_iterator it =
+          _map.find(str);
         if (it == _map.end()) {
           std::ostringstream msg;
@@ -171,37 +171,4 @@
         }
         return it->second;
-      }
-    };
-
-    template <typename Value,
-              typename Map1 = std::map<std::string, Value>,
-              typename Map2 = std::map<std::string, Value> >
-    struct DoubleMapLookUpConverter {
-      const Map1& _map1;
-      const Map2& _map2;
-
-      DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
-        : _map1(map1), _map2(map2) {}
-
-      Value operator()(const std::string& str) {
-        typename Map1::const_iterator it1 = _map1.find(str);
-        typename Map2::const_iterator it2 = _map2.find(str);
-        if (it1 == _map1.end()) {
-          if (it2 == _map2.end()) {
-            std::ostringstream msg;
-            msg << "Item not found: " << str;
-            throw FormatError(msg.str());
-          } else {
-            return it2->second;
-          }
-        } else {
-          if (it2 == _map2.end()) {
-            return it1->second;
-          } else {
-            std::ostringstream msg;
-            msg << "Item is ambigous: " << str;
-            throw FormatError(msg.str());
-          }
-        }
       }
     };
@@ -461,5 +428,5 @@
   ///\endcode
   ///
-  /// By default, the reader uses the first section in the file of the
+  /// By default the reader uses the first section in the file of the
   /// proper type. If a section has an optional name, then it can be
   /// selected for reading by giving an optional name parameter to the
@@ -596,5 +563,5 @@
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
     template <typename TDGR>
-    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
+    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, 
                                              const std::string& fn);
     template <typename TDGR>
@@ -1228,13 +1195,12 @@
 
   };
-
+  
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::DigraphReader "DigraphReader" class
-  ///
-  /// This function just returns a \ref lemon::DigraphReader
-  /// "DigraphReader" class.
-  ///
-  /// With this function a digraph can be read from an
+  /// \brief Return a \ref DigraphReader class
+  ///
+  /// This function just returns a \ref DigraphReader class.
+  ///
+  /// With this function a digraph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is network flow problem on a
@@ -1254,8 +1220,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::DigraphReader "DigraphReader"
+  /// For a complete documentation, please see the \ref DigraphReader
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::DigraphReader::run() "run()"
+  /// \warning Don't forget to put the \ref DigraphReader::run() "run()"
   /// to the end of the parameter list.
   /// \relates DigraphReader
@@ -1292,5 +1257,5 @@
   template <typename GR>
   class GraphReader;
-
+ 
   template <typename TGR>
   GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
@@ -1429,5 +1394,5 @@
     friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
     template <typename TGR>
-    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
+    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
@@ -2111,9 +2076,9 @@
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::GraphReader "GraphReader" class
-  ///
-  /// This function just returns a \ref lemon::GraphReader "GraphReader" class.
-  ///
-  /// With this function a graph can be read from an
+  /// \brief Return a \ref GraphReader class
+  ///
+  /// This function just returns a \ref GraphReader class. 
+  ///
+  /// With this function a graph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is weighted matching problem on a
@@ -2129,8 +2094,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::GraphReader "GraphReader"
+  /// For a complete documentation, please see the \ref GraphReader
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::GraphReader::run() "run()"
+  /// \warning Don't forget to put the \ref GraphReader::run() "run()"
   /// to the end of the parameter list.
   /// \relates GraphReader
@@ -2165,1072 +2129,4 @@
   }
 
-  template <typename BGR>
-  class BpGraphReader;
-
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is = std::cin);
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const std::string& fn);
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char *fn);
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief \ref lgf-format "LGF" reader for bipartite graphs
-  ///
-  /// This utility reads an \ref lgf-format "LGF" file.
-  ///
-  /// It can be used almost the same way as \c GraphReader, but it
-  /// reads the red and blue nodes from separate sections, and these
-  /// sections can contain different set of maps.
-  ///
-  /// The red and blue node maps are read from the corresponding
-  /// sections. If a map is defined with the same name in both of
-  /// these sections, then it can be read as a node map.
-  template <typename BGR>
-  class BpGraphReader {
-  public:
-
-    typedef BGR Graph;
-
-  private:
-
-    TEMPLATE_BPGRAPH_TYPEDEFS(BGR);
-
-    std::istream* _is;
-    bool local_is;
-    std::string _filename;
-
-    BGR& _graph;
-
-    std::string _nodes_caption;
-    std::string _edges_caption;
-    std::string _attributes_caption;
-
-    typedef std::map<std::string, RedNode> RedNodeIndex;
-    RedNodeIndex _red_node_index;
-    typedef std::map<std::string, BlueNode> BlueNodeIndex;
-    BlueNodeIndex _blue_node_index;
-    typedef std::map<std::string, Edge> EdgeIndex;
-    EdgeIndex _edge_index;
-
-    typedef std::vector<std::pair<std::string,
-      _reader_bits::MapStorageBase<RedNode>*> > RedNodeMaps;
-    RedNodeMaps _red_node_maps;
-    typedef std::vector<std::pair<std::string,
-      _reader_bits::MapStorageBase<BlueNode>*> > BlueNodeMaps;
-    BlueNodeMaps _blue_node_maps;
-
-    typedef std::vector<std::pair<std::string,
-      _reader_bits::MapStorageBase<Edge>*> > EdgeMaps;
-    EdgeMaps _edge_maps;
-
-    typedef std::multimap<std::string, _reader_bits::ValueStorageBase*>
-      Attributes;
-    Attributes _attributes;
-
-    bool _use_nodes;
-    bool _use_edges;
-
-    bool _skip_nodes;
-    bool _skip_edges;
-
-    int line_num;
-    std::istringstream line;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Construct an undirected graph reader, which reads from the given
-    /// input stream.
-    BpGraphReader(BGR& graph, std::istream& is = std::cin)
-      : _is(&is), local_is(false), _graph(graph),
-        _use_nodes(false), _use_edges(false),
-        _skip_nodes(false), _skip_edges(false) {}
-
-    /// \brief Constructor
-    ///
-    /// Construct an undirected graph reader, which reads from the given
-    /// file.
-    BpGraphReader(BGR& graph, const std::string& fn)
-      : _is(new std::ifstream(fn.c_str())), local_is(true),
-        _filename(fn), _graph(graph),
-        _use_nodes(false), _use_edges(false),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_is)) {
-        delete _is;
-        throw IoError("Cannot open file", fn);
-      }
-    }
-
-    /// \brief Constructor
-    ///
-    /// Construct an undirected graph reader, which reads from the given
-    /// file.
-    BpGraphReader(BGR& graph, const char* fn)
-      : _is(new std::ifstream(fn)), local_is(true),
-        _filename(fn), _graph(graph),
-        _use_nodes(false), _use_edges(false),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_is)) {
-        delete _is;
-        throw IoError("Cannot open file", fn);
-      }
-    }
-
-    /// \brief Destructor
-    ~BpGraphReader() {
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        delete it->second;
-      }
-
-      if (local_is) {
-        delete _is;
-      }
-
-    }
-
-  private:
-    template <typename TBGR>
-    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is);
-    template <typename TBGR>
-    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph,
-                                             const std::string& fn);
-    template <typename TBGR>
-    friend BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char *fn);
-
-    BpGraphReader(BpGraphReader& other)
-      : _is(other._is), local_is(other.local_is), _graph(other._graph),
-        _use_nodes(other._use_nodes), _use_edges(other._use_edges),
-        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
-
-      other._is = 0;
-      other.local_is = false;
-
-      _red_node_index.swap(other._red_node_index);
-      _blue_node_index.swap(other._blue_node_index);
-      _edge_index.swap(other._edge_index);
-
-      _red_node_maps.swap(other._red_node_maps);
-      _blue_node_maps.swap(other._blue_node_maps);
-      _edge_maps.swap(other._edge_maps);
-      _attributes.swap(other._attributes);
-
-      _nodes_caption = other._nodes_caption;
-      _edges_caption = other._edges_caption;
-      _attributes_caption = other._attributes_caption;
-
-    }
-
-    BpGraphReader& operator=(const BpGraphReader&);
-
-  public:
-
-    /// \name Reading Rules
-    /// @{
-
-    /// \brief Node map reading rule
-    ///
-    /// Add a node map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& nodeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* red_storage =
-        new _reader_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _reader_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _reader_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// \brief Node map reading rule
-    ///
-    /// Add a node map reading rule with specialized converter to the
-    /// reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& nodeMap(const std::string& caption, Map& map,
-                           const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<Node, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* red_storage =
-        new _reader_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _reader_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _reader_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// Add a red node map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& redNodeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* storage =
-        new _reader_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node map reading rule
-    ///
-    /// Add a red node map node reading rule with specialized converter to
-    /// the reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& redNodeMap(const std::string& caption, Map& map,
-                              const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<RedNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<RedNode>* storage =
-        new _reader_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// Add a blue node map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& blueNodeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<BlueNode>* storage =
-        new _reader_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node map reading rule
-    ///
-    /// Add a blue node map reading rule with specialized converter to
-    /// the reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& blueNodeMap(const std::string& caption, Map& map,
-                               const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<BlueNode, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<BlueNode>* storage =
-        new _reader_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map reading rule
-    ///
-    /// Add an edge map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& edgeMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* storage =
-        new _reader_bits::MapStorage<Edge, Map>(map);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map reading rule
-    ///
-    /// Add an edge map reading rule with specialized converter to the
-    /// reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& edgeMap(const std::string& caption, Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<Edge, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* storage =
-        new _reader_bits::MapStorage<Edge, Map, Converter>(map, converter);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc map reading rule
-    ///
-    /// Add an arc map reading rule to the reader.
-    template <typename Map>
-    BpGraphReader& arcMap(const std::string& caption, Map& map) {
-      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* forward_storage =
-        new _reader_bits::GraphArcMapStorage<Graph, true, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _reader_bits::MapStorageBase<Edge>* backward_storage =
-        new _reader_bits::GraphArcMapStorage<BGR, false, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Arc map reading rule
-    ///
-    /// Add an arc map reading rule with specialized converter to the
-    /// reader.
-    template <typename Map, typename Converter>
-    BpGraphReader& arcMap(const std::string& caption, Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::WriteMap<Arc, typename Map::Value>, Map>();
-      _reader_bits::MapStorageBase<Edge>* forward_storage =
-        new _reader_bits::GraphArcMapStorage<BGR, true, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _reader_bits::MapStorageBase<Edge>* backward_storage =
-        new _reader_bits::GraphArcMapStorage<BGR, false, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Attribute reading rule
-    ///
-    /// Add an attribute reading rule to the reader.
-    template <typename Value>
-    BpGraphReader& attribute(const std::string& caption, Value& value) {
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Value>(value);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Attribute reading rule
-    ///
-    /// Add an attribute reading rule with specialized converter to the
-    /// reader.
-    template <typename Value, typename Converter>
-    BpGraphReader& attribute(const std::string& caption, Value& value,
-                             const Converter& converter = Converter()) {
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Value, Converter>(value, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Node reading rule
-    ///
-    /// Add a node reading rule to reader.
-    BpGraphReader& node(const std::string& caption, Node& node) {
-      typedef _reader_bits::DoubleMapLookUpConverter<
-        Node, RedNodeIndex, BlueNodeIndex> Converter;
-      Converter converter(_red_node_index, _blue_node_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node reading rule
-    ///
-    /// Add a red node reading rule to reader.
-    BpGraphReader& redNode(const std::string& caption, RedNode& node) {
-      typedef _reader_bits::MapLookUpConverter<RedNode> Converter;
-      Converter converter(_red_node_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<RedNode, Converter>(node, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node reading rule
-    ///
-    /// Add a blue node reading rule to reader.
-    BpGraphReader& blueNode(const std::string& caption, BlueNode& node) {
-      typedef _reader_bits::MapLookUpConverter<BlueNode> Converter;
-      Converter converter(_blue_node_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<BlueNode, Converter>(node, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge reading rule
-    ///
-    /// Add an edge reading rule to reader.
-    BpGraphReader& edge(const std::string& caption, Edge& edge) {
-      typedef _reader_bits::MapLookUpConverter<Edge> Converter;
-      Converter converter(_edge_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Edge, Converter>(edge, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc reading rule
-    ///
-    /// Add an arc reading rule to reader.
-    BpGraphReader& arc(const std::string& caption, Arc& arc) {
-      typedef _reader_bits::GraphArcLookUpConverter<BGR> Converter;
-      Converter converter(_graph, _edge_index);
-      _reader_bits::ValueStorageBase* storage =
-        new _reader_bits::ValueStorage<Arc, Converter>(arc, converter);
-      _attributes.insert(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Select Section by Name
-    /// @{
-
-    /// \brief Set \c \@nodes section to be read
-    ///
-    /// Set \c \@nodes section to be read.
-    BpGraphReader& nodes(const std::string& caption) {
-      _nodes_caption = caption;
-      return *this;
-    }
-
-    /// \brief Set \c \@edges section to be read
-    ///
-    /// Set \c \@edges section to be read.
-    BpGraphReader& edges(const std::string& caption) {
-      _edges_caption = caption;
-      return *this;
-    }
-
-    /// \brief Set \c \@attributes section to be read
-    ///
-    /// Set \c \@attributes section to be read.
-    BpGraphReader& attributes(const std::string& caption) {
-      _attributes_caption = caption;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Using Previously Constructed Node or Edge Set
-    /// @{
-
-    /// \brief Use previously constructed node set
-    ///
-    /// Use previously constructed node set, and specify the node
-    /// label map.
-    template <typename Map>
-    BpGraphReader& useNodes(const Map& map) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
-      _use_nodes = true;
-      _writer_bits::DefaultConverter<typename Map::Value> converter;
-      for (RedNodeIt n(_graph); n != INVALID; ++n) {
-        _red_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-        _blue_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      return *this;
-    }
-
-    /// \brief Use previously constructed node set
-    ///
-    /// Use previously constructed node set, and specify the node
-    /// label map and a functor which converts the label map values to
-    /// \c std::string.
-    template <typename Map, typename Converter>
-    BpGraphReader& useNodes(const Map& map,
-                            const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_nodes, "Multiple usage of useNodes() member");
-      _use_nodes = true;
-      for (RedNodeIt n(_graph); n != INVALID; ++n) {
-        _red_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      for (BlueNodeIt n(_graph); n != INVALID; ++n) {      
-        _blue_node_index.insert(std::make_pair(converter(map[n]), n));
-      }
-      return *this;
-    }
-
-    /// \brief Use previously constructed edge set
-    ///
-    /// Use previously constructed edge set, and specify the edge
-    /// label map.
-    template <typename Map>
-    BpGraphReader& useEdges(const Map& map) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
-      _use_edges = true;
-      _writer_bits::DefaultConverter<typename Map::Value> converter;
-      for (EdgeIt a(_graph); a != INVALID; ++a) {
-        _edge_index.insert(std::make_pair(converter(map[a]), a));
-      }
-      return *this;
-    }
-
-    /// \brief Use previously constructed edge set
-    ///
-    /// Use previously constructed edge set, and specify the edge
-    /// label map and a functor which converts the label map values to
-    /// \c std::string.
-    template <typename Map, typename Converter>
-    BpGraphReader& useEdges(const Map& map,
-                            const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      LEMON_ASSERT(!_use_edges, "Multiple usage of useEdges() member");
-      _use_edges = true;
-      for (EdgeIt a(_graph); a != INVALID; ++a) {
-        _edge_index.insert(std::make_pair(converter(map[a]), a));
-      }
-      return *this;
-    }
-
-    /// \brief Skip the reading of node section
-    ///
-    /// Omit the reading of the node section. This implies that each node
-    /// map reading rule will be abandoned, and the nodes of the graph
-    /// will not be constructed, which usually cause that the edge set
-    /// could not be read due to lack of node name
-    /// could not be read due to lack of node name resolving.
-    /// Therefore \c skipEdges() function should also be used, or
-    /// \c useNodes() should be used to specify the label of the nodes.
-    BpGraphReader& skipNodes() {
-      LEMON_ASSERT(!_skip_nodes, "Skip nodes already set");
-      _skip_nodes = true;
-      return *this;
-    }
-
-    /// \brief Skip the reading of edge section
-    ///
-    /// Omit the reading of the edge section. This implies that each edge
-    /// map reading rule will be abandoned, and the edges of the graph
-    /// will not be constructed.
-    BpGraphReader& skipEdges() {
-      LEMON_ASSERT(!_skip_edges, "Skip edges already set");
-      _skip_edges = true;
-      return *this;
-    }
-
-    /// @}
-
-  private:
-
-    bool readLine() {
-      std::string str;
-      while(++line_num, std::getline(*_is, str)) {
-        line.clear(); line.str(str);
-        char c;
-        if (line >> std::ws >> c && c != '#') {
-          line.putback(c);
-          return true;
-        }
-      }
-      return false;
-    }
-
-    bool readSuccess() {
-      return static_cast<bool>(*_is);
-    }
-
-    void skipSection() {
-      char c;
-      while (readSuccess() && line >> c && c != '@') {
-        readLine();
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readRedNodes() {
-
-      std::vector<int> map_index(_red_node_maps.size());
-      int map_num, label_index;
-
-      char c;
-      if (!readLine() || !(line >> c) || c == '@') {
-        if (readSuccess() && line) line.putback(c);
-        if (!_red_node_maps.empty())
-          throw FormatError("Cannot find map names");
-        return;
-      }
-      line.putback(c);
-
-      {
-        std::map<std::string, int> maps;
-
-        std::string map;
-        int index = 0;
-        while (_reader_bits::readToken(line, map)) {
-          if (maps.find(map) != maps.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of red node map: " << map;
-            throw FormatError(msg.str());
-          }
-          maps.insert(std::make_pair(map, index));
-          ++index;
-        }
-
-        for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
-          std::map<std::string, int>::iterator jt =
-            maps.find(_red_node_maps[i].first);
-          if (jt == maps.end()) {
-            std::ostringstream msg;
-            msg << "Map not found: " << _red_node_maps[i].first;
-            throw FormatError(msg.str());
-          }
-          map_index[i] = jt->second;
-        }
-
-        {
-          std::map<std::string, int>::iterator jt = maps.find("label");
-          if (jt != maps.end()) {
-            label_index = jt->second;
-          } else {
-            label_index = -1;
-          }
-        }
-        map_num = maps.size();
-      }
-
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::vector<std::string> tokens(map_num);
-        for (int i = 0; i < map_num; ++i) {
-          if (!_reader_bits::readToken(line, tokens[i])) {
-            std::ostringstream msg;
-            msg << "Column not found (" << i + 1 << ")";
-            throw FormatError(msg.str());
-          }
-        }
-        if (line >> std::ws >> c)
-          throw FormatError("Extra character at the end of line");
-
-        RedNode n;
-        if (!_use_nodes) {
-          n = _graph.addRedNode();
-          if (label_index != -1)
-            _red_node_index.insert(std::make_pair(tokens[label_index], n));
-        } else {
-          if (label_index == -1)
-            throw FormatError("Label map not found");
-          typename std::map<std::string, RedNode>::iterator it =
-            _red_node_index.find(tokens[label_index]);
-          if (it == _red_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Node with label not found: " << tokens[label_index];
-            throw FormatError(msg.str());
-          }
-          n = it->second;
-        }
-
-        for (int i = 0; i < static_cast<int>(_red_node_maps.size()); ++i) {
-          _red_node_maps[i].second->set(n, tokens[map_index[i]]);
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readBlueNodes() {
-
-      std::vector<int> map_index(_blue_node_maps.size());
-      int map_num, label_index;
-
-      char c;
-      if (!readLine() || !(line >> c) || c == '@') {
-        if (readSuccess() && line) line.putback(c);
-        if (!_blue_node_maps.empty())
-          throw FormatError("Cannot find map names");
-        return;
-      }
-      line.putback(c);
-
-      {
-        std::map<std::string, int> maps;
-
-        std::string map;
-        int index = 0;
-        while (_reader_bits::readToken(line, map)) {
-          if (maps.find(map) != maps.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of blue node map: " << map;
-            throw FormatError(msg.str());
-          }
-          maps.insert(std::make_pair(map, index));
-          ++index;
-        }
-
-        for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
-          std::map<std::string, int>::iterator jt =
-            maps.find(_blue_node_maps[i].first);
-          if (jt == maps.end()) {
-            std::ostringstream msg;
-            msg << "Map not found: " << _blue_node_maps[i].first;
-            throw FormatError(msg.str());
-          }
-          map_index[i] = jt->second;
-        }
-
-        {
-          std::map<std::string, int>::iterator jt = maps.find("label");
-          if (jt != maps.end()) {
-            label_index = jt->second;
-          } else {
-            label_index = -1;
-          }
-        }
-        map_num = maps.size();
-      }
-
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::vector<std::string> tokens(map_num);
-        for (int i = 0; i < map_num; ++i) {
-          if (!_reader_bits::readToken(line, tokens[i])) {
-            std::ostringstream msg;
-            msg << "Column not found (" << i + 1 << ")";
-            throw FormatError(msg.str());
-          }
-        }
-        if (line >> std::ws >> c)
-          throw FormatError("Extra character at the end of line");
-
-        BlueNode n;
-        if (!_use_nodes) {
-          n = _graph.addBlueNode();
-          if (label_index != -1)
-            _blue_node_index.insert(std::make_pair(tokens[label_index], n));
-        } else {
-          if (label_index == -1)
-            throw FormatError("Label map not found");
-          typename std::map<std::string, BlueNode>::iterator it =
-            _blue_node_index.find(tokens[label_index]);
-          if (it == _blue_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Node with label not found: " << tokens[label_index];
-            throw FormatError(msg.str());
-          }
-          n = it->second;
-        }
-
-        for (int i = 0; i < static_cast<int>(_blue_node_maps.size()); ++i) {
-          _blue_node_maps[i].second->set(n, tokens[map_index[i]]);
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readEdges() {
-
-      std::vector<int> map_index(_edge_maps.size());
-      int map_num, label_index;
-
-      char c;
-      if (!readLine() || !(line >> c) || c == '@') {
-        if (readSuccess() && line) line.putback(c);
-        if (!_edge_maps.empty())
-          throw FormatError("Cannot find map names");
-        return;
-      }
-      line.putback(c);
-
-      {
-        std::map<std::string, int> maps;
-
-        std::string map;
-        int index = 0;
-        while (_reader_bits::readToken(line, map)) {
-          if (maps.find(map) != maps.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of edge map: " << map;
-            throw FormatError(msg.str());
-          }
-          maps.insert(std::make_pair(map, index));
-          ++index;
-        }
-
-        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
-          std::map<std::string, int>::iterator jt =
-            maps.find(_edge_maps[i].first);
-          if (jt == maps.end()) {
-            std::ostringstream msg;
-            msg << "Map not found: " << _edge_maps[i].first;
-            throw FormatError(msg.str());
-          }
-          map_index[i] = jt->second;
-        }
-
-        {
-          std::map<std::string, int>::iterator jt = maps.find("label");
-          if (jt != maps.end()) {
-            label_index = jt->second;
-          } else {
-            label_index = -1;
-          }
-        }
-        map_num = maps.size();
-      }
-
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::string source_token;
-        std::string target_token;
-
-        if (!_reader_bits::readToken(line, source_token))
-          throw FormatError("Red node not found");
-
-        if (!_reader_bits::readToken(line, target_token))
-          throw FormatError("Blue node not found");
-
-        std::vector<std::string> tokens(map_num);
-        for (int i = 0; i < map_num; ++i) {
-          if (!_reader_bits::readToken(line, tokens[i])) {
-            std::ostringstream msg;
-            msg << "Column not found (" << i + 1 << ")";
-            throw FormatError(msg.str());
-          }
-        }
-        if (line >> std::ws >> c)
-          throw FormatError("Extra character at the end of line");
-
-        Edge e;
-        if (!_use_edges) {
-          typename RedNodeIndex::iterator rit =
-            _red_node_index.find(source_token);
-          if (rit == _red_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Item not found: " << source_token;
-            throw FormatError(msg.str());
-          }
-          RedNode source = rit->second;
-          typename BlueNodeIndex::iterator it =
-            _blue_node_index.find(target_token);
-          if (it == _blue_node_index.end()) {
-            std::ostringstream msg;
-            msg << "Item not found: " << target_token;
-            throw FormatError(msg.str());
-          }
-          BlueNode target = it->second;
-
-          // It is checked that source is red and
-          // target is blue, so this should be safe:
-          e = _graph.addEdge(source, target);
-          if (label_index != -1)
-            _edge_index.insert(std::make_pair(tokens[label_index], e));
-        } else {
-          if (label_index == -1)
-            throw FormatError("Label map not found");
-          typename std::map<std::string, Edge>::iterator it =
-            _edge_index.find(tokens[label_index]);
-          if (it == _edge_index.end()) {
-            std::ostringstream msg;
-            msg << "Edge with label not found: " << tokens[label_index];
-            throw FormatError(msg.str());
-          }
-          e = it->second;
-        }
-
-        for (int i = 0; i < static_cast<int>(_edge_maps.size()); ++i) {
-          _edge_maps[i].second->set(e, tokens[map_index[i]]);
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-    }
-
-    void readAttributes() {
-
-      std::set<std::string> read_attr;
-
-      char c;
-      while (readLine() && line >> c && c != '@') {
-        line.putback(c);
-
-        std::string attr, token;
-        if (!_reader_bits::readToken(line, attr))
-          throw FormatError("Attribute name not found");
-        if (!_reader_bits::readToken(line, token))
-          throw FormatError("Attribute value not found");
-        if (line >> c)
-          throw FormatError("Extra character at the end of line");
-
-        {
-          std::set<std::string>::iterator it = read_attr.find(attr);
-          if (it != read_attr.end()) {
-            std::ostringstream msg;
-            msg << "Multiple occurence of attribute: " << attr;
-            throw FormatError(msg.str());
-          }
-          read_attr.insert(attr);
-        }
-
-        {
-          typename Attributes::iterator it = _attributes.lower_bound(attr);
-          while (it != _attributes.end() && it->first == attr) {
-            it->second->set(token);
-            ++it;
-          }
-        }
-
-      }
-      if (readSuccess()) {
-        line.putback(c);
-      }
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        if (read_attr.find(it->first) == read_attr.end()) {
-          std::ostringstream msg;
-          msg << "Attribute not found: " << it->first;
-          throw FormatError(msg.str());
-        }
-      }
-    }
-
-  public:
-
-    /// \name Execution of the Reader
-    /// @{
-
-    /// \brief Start the batch processing
-    ///
-    /// This function starts the batch processing
-    void run() {
-
-      LEMON_ASSERT(_is != 0, "This reader assigned to an other reader");
-
-      bool red_nodes_done = _skip_nodes;
-      bool blue_nodes_done = _skip_nodes;
-      bool edges_done = _skip_edges;
-      bool attributes_done = false;
-
-      line_num = 0;
-      readLine();
-      skipSection();
-
-      while (readSuccess()) {
-        try {
-          char c;
-          std::string section, caption;
-          line >> c;
-          _reader_bits::readToken(line, section);
-          _reader_bits::readToken(line, caption);
-
-          if (line >> c)
-            throw FormatError("Extra character at the end of line");
-
-          if (section == "red_nodes" && !red_nodes_done) {
-            if (_nodes_caption.empty() || _nodes_caption == caption) {
-              readRedNodes();
-              red_nodes_done = true;
-            }
-          } else if (section == "blue_nodes" && !blue_nodes_done) {
-            if (_nodes_caption.empty() || _nodes_caption == caption) {
-              readBlueNodes();
-              blue_nodes_done = true;
-            }
-          } else if ((section == "edges" || section == "arcs") &&
-                     !edges_done) {
-            if (_edges_caption.empty() || _edges_caption == caption) {
-              readEdges();
-              edges_done = true;
-            }
-          } else if (section == "attributes" && !attributes_done) {
-            if (_attributes_caption.empty() || _attributes_caption == caption) {
-              readAttributes();
-              attributes_done = true;
-            }
-          } else {
-            readLine();
-            skipSection();
-          }
-        } catch (FormatError& error) {
-          error.line(line_num);
-          error.file(_filename);
-          throw;
-        }
-      }
-
-      if (!red_nodes_done) {
-        throw FormatError("Section @red_nodes not found");
-      }
-
-      if (!blue_nodes_done) {
-        throw FormatError("Section @blue_nodes not found");
-      }
-
-      if (!edges_done) {
-        throw FormatError("Section @edges not found");
-      }
-
-      if (!attributes_done && !_attributes.empty()) {
-        throw FormatError("Section @attributes not found");
-      }
-
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief Return a \ref lemon::BpGraphReader "BpGraphReader" class
-  ///
-  /// This function just returns a \ref lemon::BpGraphReader
-  /// "BpGraphReader" class.
-  ///
-  /// With this function a graph can be read from an
-  /// \ref lgf-format "LGF" file or input stream with several maps and
-  /// attributes. For example, there is bipartite weighted matching problem
-  /// on a graph, i.e. a graph with a \e weight map on the edges. This
-  /// graph can be read with the following code:
-  ///
-  ///\code
-  ///ListBpGraph graph;
-  ///ListBpGraph::EdgeMap<int> weight(graph);
-  ///bpGraphReader(graph, std::cin).
-  ///  edgeMap("weight", weight).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::BpGraphReader "BpGraphReader"
-  /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::BpGraphReader::run() "run()"
-  /// to the end of the parameter list.
-  /// \relates BpGraphReader
-  /// \sa bpGraphReader(TBGR& graph, const std::string& fn)
-  /// \sa bpGraphReader(TBGR& graph, const char* fn)
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, std::istream& is) {
-    BpGraphReader<TBGR> tmp(graph, is);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphReader class
-  ///
-  /// This function just returns a \ref BpGraphReader class.
-  /// \relates BpGraphReader
-  /// \sa bpGraphReader(TBGR& graph, std::istream& is)
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const std::string& fn) {
-    BpGraphReader<TBGR> tmp(graph, fn);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphReader class
-  ///
-  /// This function just returns a \ref BpGraphReader class.
-  /// \relates BpGraphReader
-  /// \sa bpGraphReader(TBGR& graph, std::istream& is)
-  template <typename TBGR>
-  BpGraphReader<TBGR> bpGraphReader(TBGR& graph, const char* fn) {
-    BpGraphReader<TBGR> tmp(graph, fn);
-    return tmp;
-  }
-
   class SectionReader;
 
@@ -3340,5 +2236,5 @@
     /// whitespaces are trimmed from each processed string.
     ///
-    /// For example, let's see a section, which contain several
+    /// For example let's see a section, which contain several
     /// integers, which should be inserted into a vector.
     ///\code
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 1250)
+++ lemon/lgf_writer.h	(revision 646)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -186,5 +186,5 @@
       ValueStorage(const Value& value, const Converter& converter = Converter())
         : _value(value), _converter(converter) {}
-      
+
       virtual std::string get() {
         return _converter(_value);
@@ -192,47 +192,18 @@
     };
 
-    template <typename Value,
-              typename Map = std::map<Value, std::string> >
+    template <typename Value>
     struct MapLookUpConverter {
-      const Map& _map;
-
-      MapLookUpConverter(const Map& map)
+      const std::map<Value, std::string>& _map;
+
+      MapLookUpConverter(const std::map<Value, std::string>& map)
         : _map(map) {}
 
-      std::string operator()(const Value& value) {
-        typename Map::const_iterator it = _map.find(value);
+      std::string operator()(const Value& str) {
+        typename std::map<Value, std::string>::const_iterator it =
+          _map.find(str);
         if (it == _map.end()) {
           throw FormatError("Item not found");
         }
         return it->second;
-      }
-    };
-
-    template <typename Value,
-              typename Map1 = std::map<Value, std::string>,
-              typename Map2 = std::map<Value, std::string> >
-    struct DoubleMapLookUpConverter {
-      const Map1& _map1;
-      const Map2& _map2;
-
-      DoubleMapLookUpConverter(const Map1& map1, const Map2& map2)
-        : _map1(map1), _map2(map2) {}
-
-      std::string operator()(const Value& value) {
-        typename Map1::const_iterator it1 = _map1.find(value);
-        typename Map1::const_iterator it2 = _map2.find(value);
-        if (it1 == _map1.end()) {
-          if (it2 == _map2.end()) {
-            throw FormatError("Item not found");
-          } else {
-            return it2->second;
-          }
-        } else {
-          if (it2 == _map2.end()) {
-            return it1->second;
-          } else {
-            throw FormatError("Item is ambigous");
-          }
-        }
       }
     };
@@ -381,5 +352,5 @@
 
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                    std::ostream& os = std::cout);
   template <typename TDGR>
@@ -534,5 +505,5 @@
 
     template <typename TDGR>
-    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                              std::ostream& os);
     template <typename TDGR>
@@ -945,8 +916,7 @@
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::DigraphWriter "DigraphWriter" class
-  ///
-  /// This function just returns a \ref lemon::DigraphWriter
-  /// "DigraphWriter" class.
+  /// \brief Return a \ref DigraphWriter class
+  ///
+  /// This function just returns a \ref DigraphWriter class. 
   ///
   /// With this function a digraph can be write to a file or output
@@ -969,8 +939,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::DigraphWriter "DigraphWriter"
+  /// For a complete documentation, please see the \ref DigraphWriter
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::DigraphWriter::run() "run()"
+  /// \warning Don't forget to put the \ref DigraphWriter::run() "run()"
   /// to the end of the parameter list.
   /// \relates DigraphWriter
@@ -989,5 +958,5 @@
   /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                     const std::string& fn) {
     DigraphWriter<TDGR> tmp(digraph, fn);
@@ -1018,5 +987,5 @@
   /// \ingroup lemon_io
   ///
-  /// \brief \ref lgf-format "LGF" writer for undirected graphs
+  /// \brief \ref lgf-format "LGF" writer for directed graphs
   ///
   /// This utility writes an \ref lgf-format "LGF" file.
@@ -1074,6 +1043,6 @@
     /// \brief Constructor
     ///
-    /// Construct an undirected graph writer, which writes to the
-    /// given output stream.
+    /// Construct a directed graph writer, which writes to the given
+    /// output stream.
     GraphWriter(const GR& graph, std::ostream& os = std::cout)
       : _os(&os), local_os(false), _graph(graph),
@@ -1082,5 +1051,5 @@
     /// \brief Constructor
     ///
-    /// Construct a undirected graph writer, which writes to the given
+    /// Construct a directed graph writer, which writes to the given
     /// output file.
     GraphWriter(const GR& graph, const std::string& fn)
@@ -1095,5 +1064,5 @@
     /// \brief Constructor
     ///
-    /// Construct a undirected graph writer, which writes to the given
+    /// Construct a directed graph writer, which writes to the given
     /// output file.
     GraphWriter(const GR& graph, const char* fn)
@@ -1133,9 +1102,9 @@
     friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
     template <typename TGR>
-    friend GraphWriter<TGR> graphWriter(const TGR& graph,
+    friend GraphWriter<TGR> graphWriter(const TGR& graph, 
                                         const std::string& fn);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
-
+    
     GraphWriter(GraphWriter& other)
       : _os(other._os), local_os(other.local_os), _graph(other._graph),
@@ -1321,7 +1290,7 @@
     }
 
-    /// \brief Add an additional caption to the \c \@edges section
-    ///
-    /// Add an additional caption to the \c \@edges section.
+    /// \brief Add an additional caption to the \c \@arcs section
+    ///
+    /// Add an additional caption to the \c \@arcs section.
     GraphWriter& edges(const std::string& caption) {
       _edges_caption = caption;
@@ -1586,7 +1555,7 @@
   /// \ingroup lemon_io
   ///
-  /// \brief Return a \ref lemon::GraphWriter "GraphWriter" class
-  ///
-  /// This function just returns a \ref lemon::GraphWriter "GraphWriter" class.
+  /// \brief Return a \ref GraphWriter class
+  ///
+  /// This function just returns a \ref GraphWriter class. 
   ///
   /// With this function a graph can be write to a file or output
@@ -1605,8 +1574,7 @@
   ///\endcode
   ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::GraphWriter "GraphWriter"
+  /// For a complete documentation, please see the \ref GraphWriter
   /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::GraphWriter::run() "run()"
+  /// \warning Don't forget to put the \ref GraphWriter::run() "run()"
   /// to the end of the parameter list.
   /// \relates GraphWriter
@@ -1638,824 +1606,4 @@
   GraphWriter<TGR> graphWriter(const TGR& graph, const char* fn) {
     GraphWriter<TGR> tmp(graph, fn);
-    return tmp;
-  }
-
-  template <typename BGR>
-  class BpGraphWriter;
-
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
-                                    std::ostream& os = std::cout);
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const std::string& fn);
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char* fn);
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief \ref lgf-format "LGF" writer for undirected bipartite graphs
-  ///
-  /// This utility writes an \ref lgf-format "LGF" file.
-  ///
-  /// It can be used almost the same way as \c GraphWriter, but it
-  /// reads the red and blue nodes from separate sections, and these
-  /// sections can contain different set of maps.
-  ///
-  /// The red and blue node maps are written to the corresponding
-  /// sections. The node maps are written to both of these sections
-  /// with the same map name.
-  template <typename BGR>
-  class BpGraphWriter {
-  public:
-
-    typedef BGR BpGraph;
-    TEMPLATE_BPGRAPH_TYPEDEFS(BGR);
-
-  private:
-
-
-    std::ostream* _os;
-    bool local_os;
-
-    const BGR& _graph;
-
-    std::string _nodes_caption;
-    std::string _edges_caption;
-    std::string _attributes_caption;
-
-    typedef std::map<Node, std::string> RedNodeIndex;
-    RedNodeIndex _red_node_index;
-    typedef std::map<Node, std::string> BlueNodeIndex;
-    BlueNodeIndex _blue_node_index;
-    typedef std::map<Edge, std::string> EdgeIndex;
-    EdgeIndex _edge_index;
-
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::MapStorageBase<RedNode>* > > RedNodeMaps;
-    RedNodeMaps _red_node_maps;
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::MapStorageBase<BlueNode>* > > BlueNodeMaps;
-    BlueNodeMaps _blue_node_maps;
-
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::MapStorageBase<Edge>* > >EdgeMaps;
-    EdgeMaps _edge_maps;
-
-    typedef std::vector<std::pair<std::string,
-      _writer_bits::ValueStorageBase*> > Attributes;
-    Attributes _attributes;
-
-    bool _skip_nodes;
-    bool _skip_edges;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Construct a bipartite graph writer, which writes to the given
-    /// output stream.
-    BpGraphWriter(const BGR& graph, std::ostream& os = std::cout)
-      : _os(&os), local_os(false), _graph(graph),
-        _skip_nodes(false), _skip_edges(false) {}
-
-    /// \brief Constructor
-    ///
-    /// Construct a bipartite graph writer, which writes to the given
-    /// output file.
-    BpGraphWriter(const BGR& graph, const std::string& fn)
-      : _os(new std::ofstream(fn.c_str())), local_os(true), _graph(graph),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_os)) {
-        delete _os;
-        throw IoError("Cannot write file", fn);
-      }
-    }
-
-    /// \brief Constructor
-    ///
-    /// Construct a bipartite graph writer, which writes to the given
-    /// output file.
-    BpGraphWriter(const BGR& graph, const char* fn)
-      : _os(new std::ofstream(fn)), local_os(true), _graph(graph),
-        _skip_nodes(false), _skip_edges(false) {
-      if (!(*_os)) {
-        delete _os;
-        throw IoError("Cannot write file", fn);
-      }
-    }
-
-    /// \brief Destructor
-    ~BpGraphWriter() {
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        delete it->second;
-      }
-
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        delete it->second;
-      }
-
-      if (local_os) {
-        delete _os;
-      }
-    }
-
-  private:
-
-    template <typename TBGR>
-    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
-                                             std::ostream& os);
-    template <typename TBGR>
-    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph,
-                                             const std::string& fn);
-    template <typename TBGR>
-    friend BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char *fn);
-
-    BpGraphWriter(BpGraphWriter& other)
-      : _os(other._os), local_os(other.local_os), _graph(other._graph),
-        _skip_nodes(other._skip_nodes), _skip_edges(other._skip_edges) {
-
-      other._os = 0;
-      other.local_os = false;
-
-      _red_node_index.swap(other._red_node_index);
-      _blue_node_index.swap(other._blue_node_index);
-      _edge_index.swap(other._edge_index);
-
-      _red_node_maps.swap(other._red_node_maps);
-      _blue_node_maps.swap(other._blue_node_maps);
-      _edge_maps.swap(other._edge_maps);
-      _attributes.swap(other._attributes);
-
-      _nodes_caption = other._nodes_caption;
-      _edges_caption = other._edges_caption;
-      _attributes_caption = other._attributes_caption;
-    }
-
-    BpGraphWriter& operator=(const BpGraphWriter&);
-
-  public:
-
-    /// \name Writing Rules
-    /// @{
-
-    /// \brief Node map writing rule
-    ///
-    /// Add a node map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& nodeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* red_storage =
-        new _writer_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _writer_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _writer_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// \brief Node map writing rule
-    ///
-    /// Add a node map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& nodeMap(const std::string& caption, const Map& map,
-                           const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Node, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* red_storage =
-        new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, red_storage));
-      _writer_bits::MapStorageBase<BlueNode>* blue_storage =
-        new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, blue_storage));
-      return *this;
-    }
-
-    /// \brief Red node map writing rule
-    ///
-    /// Add a red node map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* storage =
-        new _writer_bits::MapStorage<RedNode, Map>(map);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node map writing rule
-    ///
-    /// Add a red node map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& redNodeMap(const std::string& caption, const Map& map,
-                              const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<RedNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<RedNode>* storage =
-        new _writer_bits::MapStorage<RedNode, Map, Converter>(map, converter);
-      _red_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node map writing rule
-    ///
-    /// Add a blue node map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<BlueNode>* storage =
-        new _writer_bits::MapStorage<BlueNode, Map>(map);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node map writing rule
-    ///
-    /// Add a blue node map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& blueNodeMap(const std::string& caption, const Map& map,
-                               const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<BlueNode, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<BlueNode>* storage =
-        new _writer_bits::MapStorage<BlueNode, Map, Converter>(map, converter);
-      _blue_node_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map writing rule
-    ///
-    /// Add an edge map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& edgeMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* storage =
-        new _writer_bits::MapStorage<Edge, Map>(map);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge map writing rule
-    ///
-    /// Add an edge map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& edgeMap(const std::string& caption, const Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Edge, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* storage =
-        new _writer_bits::MapStorage<Edge, Map, Converter>(map, converter);
-      _edge_maps.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc map writing rule
-    ///
-    /// Add an arc map writing rule to the writer.
-    template <typename Map>
-    BpGraphWriter& arcMap(const std::string& caption, const Map& map) {
-      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* forward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, true, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _writer_bits::MapStorageBase<Edge>* backward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, false, Map>(_graph, map);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Arc map writing rule
-    ///
-    /// Add an arc map writing rule with specialized converter to the
-    /// writer.
-    template <typename Map, typename Converter>
-    BpGraphWriter& arcMap(const std::string& caption, const Map& map,
-                          const Converter& converter = Converter()) {
-      checkConcept<concepts::ReadMap<Arc, typename Map::Value>, Map>();
-      _writer_bits::MapStorageBase<Edge>* forward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, true, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('+' + caption, forward_storage));
-      _writer_bits::MapStorageBase<Edge>* backward_storage =
-        new _writer_bits::GraphArcMapStorage<BGR, false, Map, Converter>
-        (_graph, map, converter);
-      _edge_maps.push_back(std::make_pair('-' + caption, backward_storage));
-      return *this;
-    }
-
-    /// \brief Attribute writing rule
-    ///
-    /// Add an attribute writing rule to the writer.
-    template <typename Value>
-    BpGraphWriter& attribute(const std::string& caption, const Value& value) {
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Value>(value);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Attribute writing rule
-    ///
-    /// Add an attribute writing rule with specialized converter to the
-    /// writer.
-    template <typename Value, typename Converter>
-    BpGraphWriter& attribute(const std::string& caption, const Value& value,
-                             const Converter& converter = Converter()) {
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Value, Converter>(value, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Node writing rule
-    ///
-    /// Add a node writing rule to the writer.
-    BpGraphWriter& node(const std::string& caption, const Node& node) {
-      typedef _writer_bits::DoubleMapLookUpConverter<
-        Node, RedNodeIndex, BlueNodeIndex> Converter;
-      Converter converter(_red_node_index, _blue_node_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Red node writing rule
-    ///
-    /// Add a red node writing rule to the writer.
-    BpGraphWriter& redNode(const std::string& caption, const RedNode& node) {
-      typedef _writer_bits::MapLookUpConverter<Node> Converter;
-      Converter converter(_red_node_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Blue node writing rule
-    ///
-    /// Add a blue node writing rule to the writer.
-    BpGraphWriter& blueNode(const std::string& caption, const BlueNode& node) {
-      typedef _writer_bits::MapLookUpConverter<Node> Converter;
-      Converter converter(_blue_node_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Node, Converter>(node, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Edge writing rule
-    ///
-    /// Add an edge writing rule to writer.
-    BpGraphWriter& edge(const std::string& caption, const Edge& edge) {
-      typedef _writer_bits::MapLookUpConverter<Edge> Converter;
-      Converter converter(_edge_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Edge, Converter>(edge, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \brief Arc writing rule
-    ///
-    /// Add an arc writing rule to writer.
-    BpGraphWriter& arc(const std::string& caption, const Arc& arc) {
-      typedef _writer_bits::GraphArcLookUpConverter<BGR> Converter;
-      Converter converter(_graph, _edge_index);
-      _writer_bits::ValueStorageBase* storage =
-        new _writer_bits::ValueStorage<Arc, Converter>(arc, converter);
-      _attributes.push_back(std::make_pair(caption, storage));
-      return *this;
-    }
-
-    /// \name Section Captions
-    /// @{
-
-    /// \brief Add an additional caption to the \c \@red_nodes and
-    /// \c \@blue_nodes section
-    ///
-    /// Add an additional caption to the \c \@red_nodes and \c
-    /// \@blue_nodes section.
-    BpGraphWriter& nodes(const std::string& caption) {
-      _nodes_caption = caption;
-      return *this;
-    }
-
-    /// \brief Add an additional caption to the \c \@edges section
-    ///
-    /// Add an additional caption to the \c \@edges section.
-    BpGraphWriter& edges(const std::string& caption) {
-      _edges_caption = caption;
-      return *this;
-    }
-
-    /// \brief Add an additional caption to the \c \@attributes section
-    ///
-    /// Add an additional caption to the \c \@attributes section.
-    BpGraphWriter& attributes(const std::string& caption) {
-      _attributes_caption = caption;
-      return *this;
-    }
-
-    /// \name Skipping Section
-    /// @{
-
-    /// \brief Skip writing the node set
-    ///
-    /// The \c \@red_nodes and \c \@blue_nodes section will not be
-    /// written to the stream.
-    BpGraphWriter& skipNodes() {
-      LEMON_ASSERT(!_skip_nodes, "Multiple usage of skipNodes() member");
-      _skip_nodes = true;
-      return *this;
-    }
-
-    /// \brief Skip writing edge set
-    ///
-    /// The \c \@edges section will not be written to the stream.
-    BpGraphWriter& skipEdges() {
-      LEMON_ASSERT(!_skip_edges, "Multiple usage of skipEdges() member");
-      _skip_edges = true;
-      return *this;
-    }
-
-    /// @}
-
-  private:
-
-    void writeRedNodes() {
-      _writer_bits::MapStorageBase<RedNode>* label = 0;
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      *_os << "@red_nodes";
-      if (!_nodes_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
-      }
-      *_os << std::endl;
-
-      if (label == 0) {
-        *_os << "label" << '\t';
-      }
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
-      }
-      *_os << std::endl;
-
-      std::vector<RedNode> nodes;
-      for (RedNodeIt n(_graph); n != INVALID; ++n) {
-        nodes.push_back(n);
-      }
-
-      if (label == 0) {
-        IdMap<BGR, Node> id_map(_graph);
-        _writer_bits::MapLess<IdMap<BGR, Node> > id_less(id_map);
-        std::sort(nodes.begin(), nodes.end(), id_less);
-      } else {
-        label->sort(nodes);
-      }
-
-      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-        RedNode n = nodes[i];
-        if (label == 0) {
-          std::ostringstream os;
-          os << _graph.id(static_cast<Node>(n));
-          _writer_bits::writeToken(*_os, os.str());
-          *_os << '\t';
-          _red_node_index.insert(std::make_pair(n, os.str()));
-        }
-        for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-             it != _red_node_maps.end(); ++it) {
-          std::string value = it->second->get(n);
-          _writer_bits::writeToken(*_os, value);
-          if (it->first == "label") {
-            _red_node_index.insert(std::make_pair(n, value));
-          }
-          *_os << '\t';
-        }
-        *_os << std::endl;
-      }
-    }
-
-    void writeBlueNodes() {
-      _writer_bits::MapStorageBase<BlueNode>* label = 0;
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      *_os << "@blue_nodes";
-      if (!_nodes_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _nodes_caption);
-      }
-      *_os << std::endl;
-
-      if (label == 0) {
-        *_os << "label" << '\t';
-      }
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
-      }
-      *_os << std::endl;
-
-      std::vector<BlueNode> nodes;
-      for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-        nodes.push_back(n);
-      }
-
-      if (label == 0) {
-        IdMap<BGR, Node> id_map(_graph);
-        _writer_bits::MapLess<IdMap<BGR, Node> > id_less(id_map);
-        std::sort(nodes.begin(), nodes.end(), id_less);
-      } else {
-        label->sort(nodes);
-      }
-
-      for (int i = 0; i < static_cast<int>(nodes.size()); ++i) {
-        BlueNode n = nodes[i];
-        if (label == 0) {
-          std::ostringstream os;
-          os << _graph.id(static_cast<Node>(n));
-          _writer_bits::writeToken(*_os, os.str());
-          *_os << '\t';
-          _blue_node_index.insert(std::make_pair(n, os.str()));
-        }
-        for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-             it != _blue_node_maps.end(); ++it) {
-          std::string value = it->second->get(n);
-          _writer_bits::writeToken(*_os, value);
-          if (it->first == "label") {
-            _blue_node_index.insert(std::make_pair(n, value));
-          }
-          *_os << '\t';
-        }
-        *_os << std::endl;
-      }
-    }
-
-    void createRedNodeIndex() {
-      _writer_bits::MapStorageBase<RedNode>* label = 0;
-      for (typename RedNodeMaps::iterator it = _red_node_maps.begin();
-           it != _red_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      if (label == 0) {
-        for (RedNodeIt n(_graph); n != INVALID; ++n) {
-          std::ostringstream os;
-          os << _graph.id(n);
-          _red_node_index.insert(std::make_pair(n, os.str()));
-        }
-      } else {
-        for (RedNodeIt n(_graph); n != INVALID; ++n) {
-          std::string value = label->get(n);
-          _red_node_index.insert(std::make_pair(n, value));
-        }
-      }
-    }
-
-    void createBlueNodeIndex() {
-      _writer_bits::MapStorageBase<BlueNode>* label = 0;
-      for (typename BlueNodeMaps::iterator it = _blue_node_maps.begin();
-           it != _blue_node_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      if (label == 0) {
-        for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-          std::ostringstream os;
-          os << _graph.id(n);
-          _blue_node_index.insert(std::make_pair(n, os.str()));
-        }
-      } else {
-        for (BlueNodeIt n(_graph); n != INVALID; ++n) {
-          std::string value = label->get(n);
-          _blue_node_index.insert(std::make_pair(n, value));
-        }
-      }
-    }
-
-    void writeEdges() {
-      _writer_bits::MapStorageBase<Edge>* label = 0;
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      *_os << "@edges";
-      if (!_edges_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _edges_caption);
-      }
-      *_os << std::endl;
-
-      *_os << '\t' << '\t';
-      if (label == 0) {
-        *_os << "label" << '\t';
-      }
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << '\t';
-      }
-      *_os << std::endl;
-
-      std::vector<Edge> edges;
-      for (EdgeIt n(_graph); n != INVALID; ++n) {
-        edges.push_back(n);
-      }
-
-      if (label == 0) {
-        IdMap<BGR, Edge> id_map(_graph);
-        _writer_bits::MapLess<IdMap<BGR, Edge> > id_less(id_map);
-        std::sort(edges.begin(), edges.end(), id_less);
-      } else {
-        label->sort(edges);
-      }
-
-      for (int i = 0; i < static_cast<int>(edges.size()); ++i) {
-        Edge e = edges[i];
-        _writer_bits::writeToken(*_os, _red_node_index.
-                                 find(_graph.redNode(e))->second);
-        *_os << '\t';
-        _writer_bits::writeToken(*_os, _blue_node_index.
-                                 find(_graph.blueNode(e))->second);
-        *_os << '\t';
-        if (label == 0) {
-          std::ostringstream os;
-          os << _graph.id(e);
-          _writer_bits::writeToken(*_os, os.str());
-          *_os << '\t';
-          _edge_index.insert(std::make_pair(e, os.str()));
-        }
-        for (typename EdgeMaps::iterator it = _edge_maps.begin();
-             it != _edge_maps.end(); ++it) {
-          std::string value = it->second->get(e);
-          _writer_bits::writeToken(*_os, value);
-          if (it->first == "label") {
-            _edge_index.insert(std::make_pair(e, value));
-          }
-          *_os << '\t';
-        }
-        *_os << std::endl;
-      }
-    }
-
-    void createEdgeIndex() {
-      _writer_bits::MapStorageBase<Edge>* label = 0;
-      for (typename EdgeMaps::iterator it = _edge_maps.begin();
-           it != _edge_maps.end(); ++it) {
-        if (it->first == "label") {
-          label = it->second;
-          break;
-        }
-      }
-
-      if (label == 0) {
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          std::ostringstream os;
-          os << _graph.id(e);
-          _edge_index.insert(std::make_pair(e, os.str()));
-        }
-      } else {
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          std::string value = label->get(e);
-          _edge_index.insert(std::make_pair(e, value));
-        }
-      }
-    }
-
-    void writeAttributes() {
-      if (_attributes.empty()) return;
-      *_os << "@attributes";
-      if (!_attributes_caption.empty()) {
-        _writer_bits::writeToken(*_os << ' ', _attributes_caption);
-      }
-      *_os << std::endl;
-      for (typename Attributes::iterator it = _attributes.begin();
-           it != _attributes.end(); ++it) {
-        _writer_bits::writeToken(*_os, it->first) << ' ';
-        _writer_bits::writeToken(*_os, it->second->get());
-        *_os << std::endl;
-      }
-    }
-
-  public:
-
-    /// \name Execution of the Writer
-    /// @{
-
-    /// \brief Start the batch processing
-    ///
-    /// This function starts the batch processing.
-    void run() {
-      if (!_skip_nodes) {
-        writeRedNodes();
-        writeBlueNodes();
-      } else {
-        createRedNodeIndex();
-        createBlueNodeIndex();
-      }
-      if (!_skip_edges) {
-        writeEdges();
-      } else {
-        createEdgeIndex();
-      }
-      writeAttributes();
-    }
-
-    /// \brief Give back the stream of the writer
-    ///
-    /// Give back the stream of the writer
-    std::ostream& ostream() {
-      return *_os;
-    }
-
-    /// @}
-  };
-
-  /// \ingroup lemon_io
-  ///
-  /// \brief Return a \ref lemon::BpGraphWriter "BpGraphWriter" class
-  ///
-  /// This function just returns a \ref lemon::BpGraphWriter
-  /// "BpGraphWriter" class.
-  ///
-  /// With this function a bipartite graph can be write to a file or output
-  /// stream in \ref lgf-format "LGF" format with several maps and
-  /// attributes. For example, with the following code a bipartite
-  /// weighted matching problem can be written to the standard output,
-  /// i.e. a graph with a \e weight map on the edges:
-  ///
-  ///\code
-  ///ListBpGraph graph;
-  ///ListBpGraph::EdgeMap<int> weight(graph);
-  ///  // Setting the weight map
-  ///bpGraphWriter(graph, std::cout).
-  ///  edgeMap("weight", weight).
-  ///  run();
-  ///\endcode
-  ///
-  /// For a complete documentation, please see the
-  /// \ref lemon::BpGraphWriter "BpGraphWriter"
-  /// class documentation.
-  /// \warning Don't forget to put the \ref lemon::BpGraphWriter::run() "run()"
-  /// to the end of the parameter list.
-  /// \relates BpGraphWriter
-  /// \sa bpGraphWriter(const TBGR& graph, const std::string& fn)
-  /// \sa bpGraphWriter(const TBGR& graph, const char* fn)
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, std::ostream& os) {
-    BpGraphWriter<TBGR> tmp(graph, os);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphWriter class
-  ///
-  /// This function just returns a \ref BpGraphWriter class.
-  /// \relates BpGraphWriter
-  /// \sa graphWriter(const TBGR& graph, std::ostream& os)
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const std::string& fn) {
-    BpGraphWriter<TBGR> tmp(graph, fn);
-    return tmp;
-  }
-
-  /// \brief Return a \ref BpGraphWriter class
-  ///
-  /// This function just returns a \ref BpGraphWriter class.
-  /// \relates BpGraphWriter
-  /// \sa graphWriter(const TBGR& graph, std::ostream& os)
-  template <typename TBGR>
-  BpGraphWriter<TBGR> bpGraphWriter(const TBGR& graph, const char* fn) {
-    BpGraphWriter<TBGR> tmp(graph, fn);
     return tmp;
   }
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 1217)
+++ lemon/list_graph.h	(revision 664)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -22,5 +22,5 @@
 ///\ingroup graphs
 ///\file
-///\brief ListDigraph and ListGraph classes.
+///\brief ListDigraph, ListGraph classes.
 
 #include <lemon/core.h>
@@ -32,6 +32,4 @@
 
 namespace lemon {
-
-  class ListDigraph;
 
   class ListDigraphBase {
@@ -65,5 +63,4 @@
     class Node {
       friend class ListDigraphBase;
-      friend class ListDigraph;
     protected:
 
@@ -81,5 +78,4 @@
     class Arc {
       friend class ListDigraphBase;
-      friend class ListDigraph;
     protected:
 
@@ -121,18 +117,18 @@
       int n;
       for(n = first_node;
-          n != -1 && nodes[n].first_out == -1;
+          n!=-1 && nodes[n].first_in == -1;
           n = nodes[n].next) {}
-      arc.id = (n == -1) ? -1 : nodes[n].first_out;
+      arc.id = (n == -1) ? -1 : nodes[n].first_in;
     }
 
     void next(Arc& arc) const {
-      if (arcs[arc.id].next_out != -1) {
-        arc.id = arcs[arc.id].next_out;
+      if (arcs[arc.id].next_in != -1) {
+        arc.id = arcs[arc.id].next_in;
       } else {
         int n;
-        for(n = nodes[arcs[arc.id].source].next;
-            n != -1 && nodes[n].first_out == -1;
+        for(n = nodes[arcs[arc.id].target].next;
+            n!=-1 && nodes[n].first_in == -1;
             n = nodes[n].next) {}
-        arc.id = (n == -1) ? -1 : nodes[n].first_out;
+        arc.id = (n == -1) ? -1 : nodes[n].first_in;
       }
     }
@@ -316,25 +312,29 @@
   ///A general directed graph structure.
 
-  ///\ref ListDigraph is a versatile and fast directed graph
-  ///implementation based on linked lists that are stored in
+  ///\ref ListDigraph is a simple and fast <em>directed graph</em>
+  ///implementation based on static linked lists that are stored in
   ///\c std::vector structures.
   ///
-  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
+  ///It conforms to the \ref concepts::Digraph "Digraph concept" and it
+  ///also provides several useful additional functionalities.
+  ///Most of the member functions and nested classes are documented
   ///only in the concept class.
   ///
-  ///This class provides only linear time counting for nodes and arcs.
-  ///
   ///\sa concepts::Digraph
-  ///\sa ListGraph
+
   class ListDigraph : public ExtendedListDigraphBase {
     typedef ExtendedListDigraphBase Parent;
 
   private:
-    /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
+    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
+
+    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
+    ///
     ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};
-    /// \brief Assignment of a digraph to another one is \e not allowed.
-    /// Use DigraphCopy instead.
+    ///\brief Assignment of ListDigraph to another one is \e not allowed.
+    ///Use copyDigraph() instead.
+
+    ///Assignment of ListDigraph to another one is \e not allowed.
+    ///Use copyDigraph() instead.
     void operator=(const ListDigraph &) {}
   public:
@@ -348,5 +348,5 @@
     ///Add a new node to the digraph.
 
-    ///This function adds a new node to the digraph.
+    ///Add a new node to the digraph.
     ///\return The new node.
     Node addNode() { return Parent::addNode(); }
@@ -354,8 +354,8 @@
     ///Add a new arc to the digraph.
 
-    ///This function adds a new arc to the digraph with source node \c s
+    ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return The new arc.
-    Arc addArc(Node s, Node t) {
+    Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
     }
@@ -363,43 +363,41 @@
     ///\brief Erase a node from the digraph.
     ///
-    ///This function erases the given node along with its outgoing and
-    ///incoming arcs from the digraph.
-    ///
-    ///\note All iterators referencing the removed node or the connected
-    ///arcs are invalidated, of course.
-    void erase(Node n) { Parent::erase(n); }
+    ///Erase a node from the digraph.
+    ///
+    void erase(const Node& n) { Parent::erase(n); }
 
     ///\brief Erase an arc from the digraph.
     ///
-    ///This function erases the given arc from the digraph.
-    ///
-    ///\note All iterators referencing the removed arc are invalidated,
-    ///of course.
-    void erase(Arc a) { Parent::erase(a); }
+    ///Erase an arc from the digraph.
+    ///
+    void erase(const Arc& a) { Parent::erase(a); }
 
     /// Node validity check
 
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the digraph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
-    /// added to the digraph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
+    ///
+    /// \warning A Node pointing to a removed item
+    /// could become valid again later if new nodes are
+    /// added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
     /// Arc validity check
 
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the digraph.
-    ///
-    /// \warning A removed arc could become valid again if new arcs are
-    /// added to the digraph.
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning An Arc pointing to a removed item
+    /// could become valid again later if new nodes are
+    /// added to the graph.
     bool valid(Arc a) const { return Parent::valid(a); }
 
-    /// Change the target node of an arc
-
-    /// This function changes the target node of the given arc \c a to \c n.
-    ///
-    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
-    ///arc remain valid, but \c InArcIt iterators are invalidated.
+    /// Change the target of \c a to \c n
+
+    /// Change the target of \c a to \c n
+    ///
+    ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
+    ///the changed arc remain valid. However <tt>InArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
@@ -408,10 +406,11 @@
       Parent::changeTarget(a,n);
     }
-    /// Change the source node of an arc
-
-    /// This function changes the source node of the given arc \c a to \c n.
-    ///
-    ///\note \c InArcIt iterators referencing the changed arc remain
-    ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
+    /// Change the source of \c a to \c n
+
+    /// Change the source of \c a to \c n
+    ///
+    ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
+    ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
@@ -421,74 +420,92 @@
     }
 
-    /// Reverse the direction of an arc.
-
-    /// This function reverses the direction of the given arc.
-    ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing
-    ///the changed arc are invalidated.
+    /// Invert the direction of an arc.
+
+    ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
+    ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
-    void reverseArc(Arc a) {
-      Node t=target(a);
-      changeTarget(a,source(a));
-      changeSource(a,t);
-    }
+    void reverseArc(Arc e) {
+      Node t=target(e);
+      changeTarget(e,source(e));
+      changeSource(e,t);
+    }
+
+    /// Reserve memory for nodes.
+
+    /// Using this function it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveArc
+    void reserveNode(int n) { nodes.reserve(n); };
+
+    /// Reserve memory for arcs.
+
+    /// Using this function it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveNode
+    void reserveArc(int m) { arcs.reserve(m); };
 
     ///Contract two nodes.
 
-    ///This function contracts the given two nodes.
-    ///Node \c v is removed, but instead of deleting its
-    ///incident arcs, they are joined to node \c u.
-    ///If the last parameter \c r is \c true (this is the default value),
-    ///then the newly created loops are removed.
-    ///
-    ///\note The moved arcs are joined to node \c u using changeSource()
-    ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
-    ///invalidated for the outgoing arcs of node \c v and \c InArcIt
-    ///iterators are invalidated for the incoming arcs of \c v.
-    ///Moreover all iterators referencing node \c v or the removed
-    ///loops are also invalidated. Other iterators remain valid.
+    ///This function contracts two nodes.
+    ///Node \p b will be removed but instead of deleting
+    ///incident arcs, they will be joined to \p a.
+    ///The last parameter \p r controls whether to remove loops. \c true
+    ///means that loops will be removed.
+    ///
+    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
+    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s
+    ///may be invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
-    void contract(Node u, Node v, bool r = true)
+    void contract(Node a, Node b, bool r = true)
     {
-      for(OutArcIt e(*this,v);e!=INVALID;) {
+      for(OutArcIt e(*this,b);e!=INVALID;) {
         OutArcIt f=e;
         ++f;
-        if(r && target(e)==u) erase(e);
-        else changeSource(e,u);
+        if(r && target(e)==a) erase(e);
+        else changeSource(e,a);
         e=f;
       }
-      for(InArcIt e(*this,v);e!=INVALID;) {
+      for(InArcIt e(*this,b);e!=INVALID;) {
         InArcIt f=e;
         ++f;
-        if(r && source(e)==u) erase(e);
-        else changeTarget(e,u);
+        if(r && source(e)==a) erase(e);
+        else changeTarget(e,a);
         e=f;
       }
-      erase(v);
+      erase(b);
     }
 
     ///Split a node.
 
-    ///This function splits the given node. First, a new node is added
-    ///to the digraph, then the source of each outgoing arc of node \c n
-    ///is moved to this new node.
-    ///If the second parameter \c connect is \c true (this is the default
-    ///value), then a new arc from node \c n to the newly created node
-    ///is also added.
+    ///This function splits a node. First a new node is added to the digraph,
+    ///then the source of each outgoing arc of \c n is moved to this new node.
+    ///If \c connect is \c true (this is the default value), then a new arc
+    ///from \c n to the newly created node is also added.
     ///\return The newly created node.
     ///
-    ///\note All iterators remain valid.
-    ///
-    ///\warning This functionality cannot be used together with the
+    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
+    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may
+    ///be invalidated.
+    ///
+    ///\warning This functionality cannot be used in conjunction with the
     ///Snapshot feature.
     Node split(Node n, bool connect = true) {
       Node b = addNode();
-      nodes[b.id].first_out=nodes[n.id].first_out;
-      nodes[n.id].first_out=-1;
-      for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
-        arcs[i].source=b.id;
+      for(OutArcIt e(*this,n);e!=INVALID;) {
+        OutArcIt f=e;
+        ++f;
+        changeSource(e,b);
+        e=f;
       }
       if (connect) addArc(n,b);
@@ -498,50 +515,18 @@
     ///Split an arc.
 
-    ///This function splits the given arc. First, a new node \c v is
-    ///added to the digraph, then the target node of the original arc
-    ///is set to \c v. Finally, an arc from \c v to the original target
-    ///is added.
+    ///This function splits an arc. First a new node \c b is added to
+    ///the digraph, then the original arc is re-targeted to \c
+    ///b. Finally an arc from \c b to the original target is added.
+    ///
     ///\return The newly created node.
-    ///
-    ///\note \c InArcIt iterators referencing the original arc are
-    ///invalidated. Other iterators remain valid.
     ///
     ///\warning This functionality cannot be used together with the
     ///Snapshot feature.
-    Node split(Arc a) {
-      Node v = addNode();
-      addArc(v,target(a));
-      changeTarget(a,v);
-      return v;
-    }
-
-    ///Clear the digraph.
-
-    ///This function erases all nodes and arcs from the digraph.
-    ///
-    ///\note All iterators of the digraph are invalidated, of course.
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for arcs.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
+    Node split(Arc e) {
+      Node b = addNode();
+      addArc(b,target(e));
+      changeTarget(e,b);
+      return b;
+    }
 
     /// \brief Class to make a snapshot of the digraph and restore
@@ -553,13 +538,7 @@
     /// restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state,
-    /// i.e. you cannot add the removed nodes and arcs again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and arc deletions and other modifications (e.g.
-    /// reversing, contracting, splitting arcs or nodes) cannot be
+    /// \warning Arc and node deletions and other modifications (e.g.
+    /// contracting, splitting, reversing arcs or nodes) cannot be
     /// restored. These events invalidate the snapshot.
-    /// However, the arcs and nodes that were added to the digraph after
-    /// making the current snapshot can be removed without invalidating it.
     class Snapshot {
     protected:
@@ -731,5 +710,5 @@
       ///
       /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
+      /// To actually make a snapshot you must call save().
       Snapshot()
         : digraph(0), node_observer_proxy(*this),
@@ -738,31 +717,30 @@
       /// \brief Constructor that immediately makes a snapshot.
       ///
-      /// This constructor immediately makes a snapshot of the given digraph.
-      Snapshot(ListDigraph &gr)
+      /// This constructor immediately makes a snapshot of the digraph.
+      /// \param _digraph The digraph we make a snapshot of.
+      Snapshot(ListDigraph &_digraph)
         : node_observer_proxy(*this),
           arc_observer_proxy(*this) {
-        attach(gr);
+        attach(_digraph);
       }
 
       /// \brief Make a snapshot.
       ///
-      /// This function makes a snapshot of the given digraph.
-      /// It can be called more than once. In case of a repeated
+      /// Make a snapshot of the digraph.
+      ///
+      /// This function can be called more than once. In case of a repeated
       /// call, the previous snapshot gets lost.
-      void save(ListDigraph &gr) {
+      /// \param _digraph The digraph we make the snapshot of.
+      void save(ListDigraph &_digraph) {
         if (attached()) {
           detach();
           clear();
         }
-        attach(gr);
+        attach(_digraph);
       }
 
       /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListDigraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
+      //
+      /// Undo the changes until the last snapshot created by save().
       void restore() {
         detach();
@@ -778,7 +756,7 @@
       }
 
-      /// \brief Returns \c true if the snapshot is valid.
+      /// \brief Gives back true when the snapshot is valid.
       ///
-      /// This function returns \c true if the snapshot is valid.
+      /// Gives back true when the snapshot is valid.
       bool valid() const {
         return attached();
@@ -817,4 +795,8 @@
 
     typedef ListGraphBase Graph;
+
+    class Node;
+    class Arc;
+    class Edge;
 
     class Node {
@@ -866,4 +848,6 @@
       bool operator<(const Arc& arc) const {return id < arc.id;}
     };
+
+
 
     ListGraphBase()
@@ -1181,25 +1165,29 @@
   ///A general undirected graph structure.
 
-  ///\ref ListGraph is a versatile and fast undirected graph
-  ///implementation based on linked lists that are stored in
+  ///\ref ListGraph is a simple and fast <em>undirected graph</em>
+  ///implementation based on static linked lists that are stored in
   ///\c std::vector structures.
   ///
-  ///This type fully conforms to the \ref concepts::Graph "Graph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
+  ///It conforms to the \ref concepts::Graph "Graph concept" and it
+  ///also provides several useful additional functionalities.
+  ///Most of the member functions and nested classes are documented
   ///only in the concept class.
   ///
-  ///This class provides only linear time counting for nodes, edges and arcs.
-  ///
   ///\sa concepts::Graph
-  ///\sa ListDigraph
+
   class ListGraph : public ExtendedListGraphBase {
     typedef ExtendedListGraphBase Parent;
 
   private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
+    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
+
+    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
+    ///
     ListGraph(const ListGraph &) :ExtendedListGraphBase()  {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
+    ///\brief Assignment of ListGraph to another one is \e not allowed.
+    ///Use copyGraph() instead.
+
+    ///Assignment of ListGraph to another one is \e not allowed.
+    ///Use copyGraph() instead.
     void operator=(const ListGraph &) {}
   public:
@@ -1214,5 +1202,5 @@
     /// \brief Add a new node to the graph.
     ///
-    /// This function adds a new node to the graph.
+    /// Add a new node to the graph.
     /// \return The new node.
     Node addNode() { return Parent::addNode(); }
@@ -1220,60 +1208,57 @@
     /// \brief Add a new edge to the graph.
     ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
+    /// Add a new edge to the graph with source node \c s
+    /// and target node \c t.
     /// \return The new edge.
-    Edge addEdge(Node u, Node v) {
-      return Parent::addEdge(u, v);
-    }
-
-    ///\brief Erase a node from the graph.
-    ///
-    /// This function erases the given node along with its incident arcs
-    /// from the graph.
-    ///
-    /// \note All iterators referencing the removed node or the incident
-    /// edges are invalidated, of course.
-    void erase(Node n) { Parent::erase(n); }
-
-    ///\brief Erase an edge from the graph.
-    ///
-    /// This function erases the given edge from the graph.
-    ///
-    /// \note All iterators referencing the removed edge are invalidated,
-    /// of course.
-    void erase(Edge e) { Parent::erase(e); }
+    Edge addEdge(const Node& s, const Node& t) {
+      return Parent::addEdge(s, t);
+    }
+
+    /// \brief Erase a node from the graph.
+    ///
+    /// Erase a node from the graph.
+    ///
+    void erase(const Node& n) { Parent::erase(n); }
+
+    /// \brief Erase an edge from the graph.
+    ///
+    /// Erase an edge from the graph.
+    ///
+    void erase(const Edge& e) { Parent::erase(e); }
     /// Node validity check
 
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
+    ///
+    /// \warning A Node pointing to a removed item
+    /// could become valid again later if new nodes are
     /// added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
+    /// Arc validity check
+
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning An Arc pointing to a removed item
+    /// could become valid again later if new edges are
+    /// added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
     /// Edge validity check
 
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge could become valid again if new edges are
+    /// This function gives back true if the given edge is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning A Edge pointing to a removed item
+    /// could become valid again later if new edges are
     /// added to the graph.
     bool valid(Edge e) const { return Parent::valid(e); }
-    /// Arc validity check
-
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    /// \brief Change the first node of an edge.
-    ///
-    /// This function changes the first node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt and \c ArcIt iterators referencing the
-    ///changed edge are invalidated and all other iterators whose
-    ///base node is the changed node are also invalidated.
+    /// \brief Change the end \c u of \c e to \c n
+    ///
+    /// This function changes the end \c u of \c e to node \c n.
+    ///
+    ///\note The <tt>EdgeIt</tt>s and <tt>ArcIt</tt>s referencing the
+    ///changed edge are invalidated and if the changed node is the
+    ///base node of an iterator then this iterator is also
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1282,12 +1267,11 @@
       Parent::changeU(e,n);
     }
-    /// \brief Change the second node of an edge.
-    ///
-    /// This function changes the second node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt iterators referencing the changed edge remain
-    ///valid, but \c ArcIt iterators referencing the changed edge and
-    ///all other iterators whose base node is the changed node are also
-    ///invalidated.
+    /// \brief Change the end \c v of \c e to \c n
+    ///
+    /// This function changes the end \c v of \c e to \c n.
+    ///
+    ///\note The <tt>EdgeIt</tt>s referencing the changed edge remain
+    ///valid, however <tt>ArcIt</tt>s and if the changed node is the
+    ///base node of an iterator then this iterator is invalidated.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1296,18 +1280,14 @@
       Parent::changeV(e,n);
     }
-
     /// \brief Contract two nodes.
     ///
-    /// This function contracts the given two nodes.
-    /// Node \c b is removed, but instead of deleting
-    /// its incident edges, they are joined to node \c a.
-    /// If the last parameter \c r is \c true (this is the default value),
-    /// then the newly created loops are removed.
-    ///
-    /// \note The moved edges are joined to node \c a using changeU()
-    /// or changeV(), thus all edge and arc iterators whose base node is
-    /// \c b are invalidated.
-    /// Moreover all iterators referencing node \c b or the removed
-    /// loops are also invalidated. Other iterators remain valid.
+    /// This function contracts two nodes.
+    /// Node \p b will be removed but instead of deleting
+    /// its neighboring arcs, they will be joined to \p a.
+    /// The last parameter \p r controls whether to remove loops. \c true
+    /// means that loops will be removed.
+    ///
+    /// \note The <tt>ArcIt</tt>s referencing a moved arc remain
+    /// valid.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1328,32 +1308,4 @@
     }
 
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    ///\note All iterators of the graph are invalidated, of course.
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
@@ -1365,13 +1317,7 @@
     /// using the restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state,
-    /// i.e. you cannot add the removed nodes and edges again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and edge deletions and other modifications
-    /// (e.g. changing the end-nodes of edges or contracting nodes)
-    /// cannot be restored. These events invalidate the snapshot.
-    /// However, the edges and nodes that were added to the graph after
-    /// making the current snapshot can be removed without invalidating it.
+    /// \warning Edge and node deletions and other modifications
+    /// (e.g. changing nodes of edges, contracting nodes) cannot be
+    /// restored. These events invalidate the snapshot.
     class Snapshot {
     protected:
@@ -1543,5 +1489,5 @@
       ///
       /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
+      /// To actually make a snapshot you must call save().
       Snapshot()
         : graph(0), node_observer_proxy(*this),
@@ -1550,31 +1496,30 @@
       /// \brief Constructor that immediately makes a snapshot.
       ///
-      /// This constructor immediately makes a snapshot of the given graph.
-      Snapshot(ListGraph &gr)
+      /// This constructor immediately makes a snapshot of the graph.
+      /// \param _graph The graph we make a snapshot of.
+      Snapshot(ListGraph &_graph)
         : node_observer_proxy(*this),
           edge_observer_proxy(*this) {
-        attach(gr);
+        attach(_graph);
       }
 
       /// \brief Make a snapshot.
       ///
-      /// This function makes a snapshot of the given graph.
-      /// It can be called more than once. In case of a repeated
+      /// Make a snapshot of the graph.
+      ///
+      /// This function can be called more than once. In case of a repeated
       /// call, the previous snapshot gets lost.
-      void save(ListGraph &gr) {
+      /// \param _graph The graph we make the snapshot of.
+      void save(ListGraph &_graph) {
         if (attached()) {
           detach();
           clear();
         }
-        attach(gr);
+        attach(_graph);
       }
 
       /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListGraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
+      //
+      /// Undo the changes until the last snapshot created by save().
       void restore() {
         detach();
@@ -1590,7 +1535,7 @@
       }
 
-      /// \brief Returns \c true if the snapshot is valid.
+      /// \brief Gives back true when the snapshot is valid.
       ///
-      /// This function returns \c true if the snapshot is valid.
+      /// Gives back true when the snapshot is valid.
       bool valid() const {
         return attached();
@@ -1600,909 +1545,4 @@
 
   /// @}
-
-  class ListBpGraphBase {
-
-  protected:
-
-    struct NodeT {
-      int first_out;
-      int prev, next;
-      int partition_prev, partition_next;
-      int partition_index;
-      bool red;
-    };
-
-    struct ArcT {
-      int target;
-      int prev_out, next_out;
-    };
-
-    std::vector<NodeT> nodes;
-
-    int first_node, first_red, first_blue;
-    int max_red, max_blue;
-
-    int first_free_red, first_free_blue;
-
-    std::vector<ArcT> arcs;
-
-    int first_free_arc;
-
-  public:
-
-    typedef ListBpGraphBase BpGraph;
-
-    class Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Node(int pid) { id = pid;}
-
-    public:
-      Node() {}
-      Node (Invalid) { id = -1; }
-      bool operator==(const Node& node) const {return id == node.id;}
-      bool operator!=(const Node& node) const {return id != node.id;}
-      bool operator<(const Node& node) const {return id < node.id;}
-    };
-
-    class RedNode : public Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      explicit RedNode(int pid) : Node(pid) {}
-
-    public:
-      RedNode() {}
-      RedNode(const RedNode& node) : Node(node) {}
-      RedNode(Invalid) : Node(INVALID){}
-    };
-
-    class BlueNode : public Node {
-      friend class ListBpGraphBase;
-    protected:
-
-      explicit BlueNode(int pid) : Node(pid) {}
-
-    public:
-      BlueNode() {}
-      BlueNode(const BlueNode& node) : Node(node) {}
-      BlueNode(Invalid) : Node(INVALID){}
-    };
-
-    class Edge {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Edge(int pid) { id = pid;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { id = -1; }
-      bool operator==(const Edge& edge) const {return id == edge.id;}
-      bool operator!=(const Edge& edge) const {return id != edge.id;}
-      bool operator<(const Edge& edge) const {return id < edge.id;}
-    };
-
-    class Arc {
-      friend class ListBpGraphBase;
-    protected:
-
-      int id;
-      explicit Arc(int pid) { id = pid;}
-
-    public:
-      operator Edge() const {
-        return id != -1 ? edgeFromId(id / 2) : INVALID;
-      }
-
-      Arc() {}
-      Arc (Invalid) { id = -1; }
-      bool operator==(const Arc& arc) const {return id == arc.id;}
-      bool operator!=(const Arc& arc) const {return id != arc.id;}
-      bool operator<(const Arc& arc) const {return id < arc.id;}
-    };
-
-    ListBpGraphBase()
-      : nodes(), first_node(-1),
-        first_red(-1), first_blue(-1),
-        max_red(-1), max_blue(-1),
-        first_free_red(-1), first_free_blue(-1),
-        arcs(), first_free_arc(-1) {}
-
-
-    bool red(Node n) const { return nodes[n.id].red; }
-    bool blue(Node n) const { return !nodes[n.id].red; }
-
-    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n.id); }
-    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n.id); }
-
-    int maxNodeId() const { return nodes.size()-1; }
-    int maxRedId() const { return max_red; }
-    int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return arcs.size() / 2 - 1; }
-    int maxArcId() const { return arcs.size()-1; }
-
-    Node source(Arc e) const { return Node(arcs[e.id ^ 1].target); }
-    Node target(Arc e) const { return Node(arcs[e.id].target); }
-
-    RedNode redNode(Edge e) const {
-      return RedNode(arcs[2 * e.id].target);
-    }
-    BlueNode blueNode(Edge e) const {
-      return BlueNode(arcs[2 * e.id + 1].target);
-    }
-
-    static bool direction(Arc e) {
-      return (e.id & 1) == 1;
-    }
-
-    static Arc direct(Edge e, bool d) {
-      return Arc(e.id * 2 + (d ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node.id = first_node;
-    }
-
-    void next(Node& node) const {
-      node.id = nodes[node.id].next;
-    }
-
-    void first(RedNode& node) const {
-      node.id = first_red;
-    }
-
-    void next(RedNode& node) const {
-      node.id = nodes[node.id].partition_next;
-    }
-
-    void first(BlueNode& node) const {
-      node.id = first_blue;
-    }
-
-    void next(BlueNode& node) const {
-      node.id = nodes[node.id].partition_next;
-    }    
-
-    void first(Arc& e) const {
-      int n = first_node;
-      while (n != -1 && nodes[n].first_out == -1) {
-        n = nodes[n].next;
-      }
-      e.id = (n == -1) ? -1 : nodes[n].first_out;
-    }
-
-    void next(Arc& e) const {
-      if (arcs[e.id].next_out != -1) {
-        e.id = arcs[e.id].next_out;
-      } else {
-        int n = nodes[arcs[e.id ^ 1].target].next;
-        while(n != -1 && nodes[n].first_out == -1) {
-          n = nodes[n].next;
-        }
-        e.id = (n == -1) ? -1 : nodes[n].first_out;
-      }
-    }
-
-    void first(Edge& e) const {
-      int n = first_node;
-      while (n != -1) {
-        e.id = nodes[n].first_out;
-        while ((e.id & 1) != 1) {
-          e.id = arcs[e.id].next_out;
-        }
-        if (e.id != -1) {
-          e.id /= 2;
-          return;
-        }
-        n = nodes[n].next;
-      }
-      e.id = -1;
-    }
-
-    void next(Edge& e) const {
-      int n = arcs[e.id * 2].target;
-      e.id = arcs[(e.id * 2) | 1].next_out;
-      while ((e.id & 1) != 1) {
-        e.id = arcs[e.id].next_out;
-      }
-      if (e.id != -1) {
-        e.id /= 2;
-        return;
-      }
-      n = nodes[n].next;
-      while (n != -1) {
-        e.id = nodes[n].first_out;
-        while ((e.id & 1) != 1) {
-          e.id = arcs[e.id].next_out;
-        }
-        if (e.id != -1) {
-          e.id /= 2;
-          return;
-        }
-        n = nodes[n].next;
-      }
-      e.id = -1;
-    }
-
-    void firstOut(Arc &e, const Node& v) const {
-      e.id = nodes[v.id].first_out;
-    }
-    void nextOut(Arc &e) const {
-      e.id = arcs[e.id].next_out;
-    }
-
-    void firstIn(Arc &e, const Node& v) const {
-      e.id = ((nodes[v.id].first_out) ^ 1);
-      if (e.id == -2) e.id = -1;
-    }
-    void nextIn(Arc &e) const {
-      e.id = ((arcs[e.id ^ 1].next_out) ^ 1);
-      if (e.id == -2) e.id = -1;
-    }
-
-    void firstInc(Edge &e, bool& d, const Node& v) const {
-      int a = nodes[v.id].first_out;
-      if (a != -1 ) {
-        e.id = a / 2;
-        d = ((a & 1) == 1);
-      } else {
-        e.id = -1;
-        d = true;
-      }
-    }
-    void nextInc(Edge &e, bool& d) const {
-      int a = (arcs[(e.id * 2) | (d ? 1 : 0)].next_out);
-      if (a != -1 ) {
-        e.id = a / 2;
-        d = ((a & 1) == 1);
-      } else {
-        e.id = -1;
-        d = true;
-      }
-    }
-
-    static int id(Node v) { return v.id; }
-    int id(RedNode v) const { return nodes[v.id].partition_index; }
-    int id(BlueNode v) const { return nodes[v.id].partition_index; }
-    static int id(Arc e) { return e.id; }
-    static int id(Edge e) { return e.id; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    bool valid(Node n) const {
-      return n.id >= 0 && n.id < static_cast<int>(nodes.size()) &&
-        nodes[n.id].prev != -2;
-    }
-
-    bool valid(Arc a) const {
-      return a.id >= 0 && a.id < static_cast<int>(arcs.size()) &&
-        arcs[a.id].prev_out != -2;
-    }
-
-    bool valid(Edge e) const {
-      return e.id >= 0 && 2 * e.id < static_cast<int>(arcs.size()) &&
-        arcs[2 * e.id].prev_out != -2;
-    }
-
-    RedNode addRedNode() {
-      int n;
-
-      if(first_free_red==-1) {
-        n = nodes.size();
-        nodes.push_back(NodeT());
-        nodes[n].partition_index = ++max_red;
-        nodes[n].red = true;
-      } else {
-        n = first_free_red;
-        first_free_red = nodes[n].next;
-      }
-
-      nodes[n].next = first_node;
-      if (first_node != -1) nodes[first_node].prev = n;
-      first_node = n;
-      nodes[n].prev = -1;
-
-      nodes[n].partition_next = first_red;
-      if (first_red != -1) nodes[first_red].partition_prev = n;
-      first_red = n;
-      nodes[n].partition_prev = -1;
-
-      nodes[n].first_out = -1;
-
-      return RedNode(n);
-    }
-
-    BlueNode addBlueNode() {
-      int n;
-
-      if(first_free_blue==-1) {
-        n = nodes.size();
-        nodes.push_back(NodeT());
-        nodes[n].partition_index = ++max_blue;
-        nodes[n].red = false;
-      } else {
-        n = first_free_blue;
-        first_free_blue = nodes[n].next;
-      }
-
-      nodes[n].next = first_node;
-      if (first_node != -1) nodes[first_node].prev = n;
-      first_node = n;
-      nodes[n].prev = -1;
-
-      nodes[n].partition_next = first_blue;
-      if (first_blue != -1) nodes[first_blue].partition_prev = n;
-      first_blue = n;
-      nodes[n].partition_prev = -1;
-
-      nodes[n].first_out = -1;
-
-      return BlueNode(n);
-    }
-
-    Edge addEdge(Node u, Node v) {
-      int n;
-
-      if (first_free_arc == -1) {
-        n = arcs.size();
-        arcs.push_back(ArcT());
-        arcs.push_back(ArcT());
-      } else {
-        n = first_free_arc;
-        first_free_arc = arcs[n].next_out;
-      }
-
-      arcs[n].target = u.id;
-      arcs[n | 1].target = v.id;
-
-      arcs[n].next_out = nodes[v.id].first_out;
-      if (nodes[v.id].first_out != -1) {
-        arcs[nodes[v.id].first_out].prev_out = n;
-      }
-      arcs[n].prev_out = -1;
-      nodes[v.id].first_out = n;
-
-      arcs[n | 1].next_out = nodes[u.id].first_out;
-      if (nodes[u.id].first_out != -1) {
-        arcs[nodes[u.id].first_out].prev_out = (n | 1);
-      }
-      arcs[n | 1].prev_out = -1;
-      nodes[u.id].first_out = (n | 1);
-
-      return Edge(n / 2);
-    }
-
-    void erase(const Node& node) {
-      int n = node.id;
-
-      if(nodes[n].next != -1) {
-        nodes[nodes[n].next].prev = nodes[n].prev;
-      }
-
-      if(nodes[n].prev != -1) {
-        nodes[nodes[n].prev].next = nodes[n].next;
-      } else {
-        first_node = nodes[n].next;
-      }
-
-      if (nodes[n].partition_next != -1) {
-        nodes[nodes[n].partition_next].partition_prev = nodes[n].partition_prev;
-      }
-
-      if (nodes[n].partition_prev != -1) {
-        nodes[nodes[n].partition_prev].partition_next = nodes[n].partition_next;
-      } else {
-        if (nodes[n].red) {
-          first_red = nodes[n].partition_next;
-        } else {
-          first_blue = nodes[n].partition_next;
-        }
-      }
-
-      if (nodes[n].red) {
-        nodes[n].next = first_free_red;
-        first_free_red = n;
-      } else {
-        nodes[n].next = first_free_blue;
-        first_free_blue = n;
-      }
-      nodes[n].prev = -2;
-    }
-
-    void erase(const Edge& edge) {
-      int n = edge.id * 2;
-
-      if (arcs[n].next_out != -1) {
-        arcs[arcs[n].next_out].prev_out = arcs[n].prev_out;
-      }
-
-      if (arcs[n].prev_out != -1) {
-        arcs[arcs[n].prev_out].next_out = arcs[n].next_out;
-      } else {
-        nodes[arcs[n | 1].target].first_out = arcs[n].next_out;
-      }
-
-      if (arcs[n | 1].next_out != -1) {
-        arcs[arcs[n | 1].next_out].prev_out = arcs[n | 1].prev_out;
-      }
-
-      if (arcs[n | 1].prev_out != -1) {
-        arcs[arcs[n | 1].prev_out].next_out = arcs[n | 1].next_out;
-      } else {
-        nodes[arcs[n].target].first_out = arcs[n | 1].next_out;
-      }
-
-      arcs[n].next_out = first_free_arc;
-      first_free_arc = n;
-      arcs[n].prev_out = -2;
-      arcs[n | 1].prev_out = -2;
-
-    }
-
-    void clear() {
-      arcs.clear();
-      nodes.clear();
-      first_node = first_free_arc = first_red = first_blue =
-        max_red = max_blue = first_free_red = first_free_blue = -1;
-    }
-
-  protected:
-
-    void changeRed(Edge e, RedNode n) {
-      if(arcs[(2 * e.id) | 1].next_out != -1) {
-        arcs[arcs[(2 * e.id) | 1].next_out].prev_out =
-          arcs[(2 * e.id) | 1].prev_out;
-      }
-      if(arcs[(2 * e.id) | 1].prev_out != -1) {
-        arcs[arcs[(2 * e.id) | 1].prev_out].next_out =
-          arcs[(2 * e.id) | 1].next_out;
-      } else {
-        nodes[arcs[2 * e.id].target].first_out =
-          arcs[(2 * e.id) | 1].next_out;
-      }
-
-      if (nodes[n.id].first_out != -1) {
-        arcs[nodes[n.id].first_out].prev_out = ((2 * e.id) | 1);
-      }
-      arcs[2 * e.id].target = n.id;
-      arcs[(2 * e.id) | 1].prev_out = -1;
-      arcs[(2 * e.id) | 1].next_out = nodes[n.id].first_out;
-      nodes[n.id].first_out = ((2 * e.id) | 1);
-    }
-
-    void changeBlue(Edge e, BlueNode n) {
-       if(arcs[2 * e.id].next_out != -1) {
-        arcs[arcs[2 * e.id].next_out].prev_out = arcs[2 * e.id].prev_out;
-      }
-      if(arcs[2 * e.id].prev_out != -1) {
-        arcs[arcs[2 * e.id].prev_out].next_out =
-          arcs[2 * e.id].next_out;
-      } else {
-        nodes[arcs[(2 * e.id) | 1].target].first_out =
-          arcs[2 * e.id].next_out;
-      }
-
-      if (nodes[n.id].first_out != -1) {
-        arcs[nodes[n.id].first_out].prev_out = 2 * e.id;
-      }
-      arcs[(2 * e.id) | 1].target = n.id;
-      arcs[2 * e.id].prev_out = -1;
-      arcs[2 * e.id].next_out = nodes[n.id].first_out;
-      nodes[n.id].first_out = 2 * e.id;
-    }
-
-  };
-
-  typedef BpGraphExtender<ListBpGraphBase> ExtendedListBpGraphBase;
-
-
-  /// \addtogroup graphs
-  /// @{
-
-  ///A general undirected graph structure.
-
-  ///\ref ListBpGraph is a versatile and fast undirected graph
-  ///implementation based on linked lists that are stored in
-  ///\c std::vector structures.
-  ///
-  ///This type fully conforms to the \ref concepts::BpGraph "BpGraph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
-  ///only in the concept class.
-  ///
-  ///This class provides only linear time counting for nodes, edges and arcs.
-  ///
-  ///\sa concepts::BpGraph
-  ///\sa ListDigraph
-  class ListBpGraph : public ExtendedListBpGraphBase {
-    typedef ExtendedListBpGraphBase Parent;
-
-  private:
-    /// BpGraphs are \e not copy constructible. Use BpGraphCopy instead.
-    ListBpGraph(const ListBpGraph &) :ExtendedListBpGraphBase()  {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use BpGraphCopy instead.
-    void operator=(const ListBpGraph &) {}
-  public:
-    /// Constructor
-
-    /// Constructor.
-    ///
-    ListBpGraph() {}
-
-    typedef Parent::OutArcIt IncEdgeIt;
-
-    /// \brief Add a new red node to the graph.
-    ///
-    /// This function adds a red new node to the graph.
-    /// \return The new node.
-    RedNode addRedNode() { return Parent::addRedNode(); }
-
-    /// \brief Add a new blue node to the graph.
-    ///
-    /// This function adds a blue new node to the graph.
-    /// \return The new node.
-    BlueNode addBlueNode() { return Parent::addBlueNode(); }
-
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(RedNode u, BlueNode v) {
-      return Parent::addEdge(u, v);
-    }
-    Edge addEdge(BlueNode v, RedNode u) {
-      return Parent::addEdge(u, v);
-    }
-
-    ///\brief Erase a node from the graph.
-    ///
-    /// This function erases the given node along with its incident arcs
-    /// from the graph.
-    ///
-    /// \note All iterators referencing the removed node or the incident
-    /// edges are invalidated, of course.
-    void erase(Node n) { Parent::erase(n); }
-
-    ///\brief Erase an edge from the graph.
-    ///
-    /// This function erases the given edge from the graph.
-    ///
-    /// \note All iterators referencing the removed edge are invalidated,
-    /// of course.
-    void erase(Edge e) { Parent::erase(e); }
-    /// Node validity check
-
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
-    /// added to the graph.
-    bool valid(Node n) const { return Parent::valid(n); }
-    /// Edge validity check
-
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Edge e) const { return Parent::valid(e); }
-    /// Arc validity check
-
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    /// \brief Change the red node of an edge.
-    ///
-    /// This function changes the red node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt and \c ArcIt iterators referencing the
-    ///changed edge are invalidated and all other iterators whose
-    ///base node is the changed node are also invalidated.
-    ///
-    ///\warning This functionality cannot be used together with the
-    ///Snapshot feature.
-    void changeRed(Edge e, RedNode n) {
-      Parent::changeRed(e, n);
-    }
-    /// \brief Change the blue node of an edge.
-    ///
-    /// This function changes the blue node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt iterators referencing the changed edge remain
-    ///valid, but \c ArcIt iterators referencing the changed edge and
-    ///all other iterators whose base node is the changed node are also
-    ///invalidated.
-    ///
-    ///\warning This functionality cannot be used together with the
-    ///Snapshot feature.
-    void changeBlue(Edge e, BlueNode n) {
-      Parent::changeBlue(e, n);
-    }
-
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    ///\note All iterators of the graph are invalidated, of course.
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
-
-    /// \brief Class to make a snapshot of the graph and restore
-    /// it later.
-    ///
-    /// Class to make a snapshot of the graph and restore it later.
-    ///
-    /// The newly added nodes and edges can be removed
-    /// using the restore() function.
-    ///
-    /// \note After a state is restored, you cannot restore a later state,
-    /// i.e. you cannot add the removed nodes and edges again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and edge deletions and other modifications
-    /// (e.g. changing the end-nodes of edges or contracting nodes)
-    /// cannot be restored. These events invalidate the snapshot.
-    /// However, the edges and nodes that were added to the graph after
-    /// making the current snapshot can be removed without invalidating it.
-    class Snapshot {
-    protected:
-
-      typedef Parent::NodeNotifier NodeNotifier;
-
-      class NodeObserverProxy : public NodeNotifier::ObserverBase {
-      public:
-
-        NodeObserverProxy(Snapshot& _snapshot)
-          : snapshot(_snapshot) {}
-
-        using NodeNotifier::ObserverBase::attach;
-        using NodeNotifier::ObserverBase::detach;
-        using NodeNotifier::ObserverBase::attached;
-
-      protected:
-
-        virtual void add(const Node& node) {
-          snapshot.addNode(node);
-        }
-        virtual void add(const std::vector<Node>& nodes) {
-          for (int i = nodes.size() - 1; i >= 0; ++i) {
-            snapshot.addNode(nodes[i]);
-          }
-        }
-        virtual void erase(const Node& node) {
-          snapshot.eraseNode(node);
-        }
-        virtual void erase(const std::vector<Node>& nodes) {
-          for (int i = 0; i < int(nodes.size()); ++i) {
-            snapshot.eraseNode(nodes[i]);
-          }
-        }
-        virtual void build() {
-          Node node;
-          std::vector<Node> nodes;
-          for (notifier()->first(node); node != INVALID;
-               notifier()->next(node)) {
-            nodes.push_back(node);
-          }
-          for (int i = nodes.size() - 1; i >= 0; --i) {
-            snapshot.addNode(nodes[i]);
-          }
-        }
-        virtual void clear() {
-          Node node;
-          for (notifier()->first(node); node != INVALID;
-               notifier()->next(node)) {
-            snapshot.eraseNode(node);
-          }
-        }
-
-        Snapshot& snapshot;
-      };
-
-      class EdgeObserverProxy : public EdgeNotifier::ObserverBase {
-      public:
-
-        EdgeObserverProxy(Snapshot& _snapshot)
-          : snapshot(_snapshot) {}
-
-        using EdgeNotifier::ObserverBase::attach;
-        using EdgeNotifier::ObserverBase::detach;
-        using EdgeNotifier::ObserverBase::attached;
-
-      protected:
-
-        virtual void add(const Edge& edge) {
-          snapshot.addEdge(edge);
-        }
-        virtual void add(const std::vector<Edge>& edges) {
-          for (int i = edges.size() - 1; i >= 0; ++i) {
-            snapshot.addEdge(edges[i]);
-          }
-        }
-        virtual void erase(const Edge& edge) {
-          snapshot.eraseEdge(edge);
-        }
-        virtual void erase(const std::vector<Edge>& edges) {
-          for (int i = 0; i < int(edges.size()); ++i) {
-            snapshot.eraseEdge(edges[i]);
-          }
-        }
-        virtual void build() {
-          Edge edge;
-          std::vector<Edge> edges;
-          for (notifier()->first(edge); edge != INVALID;
-               notifier()->next(edge)) {
-            edges.push_back(edge);
-          }
-          for (int i = edges.size() - 1; i >= 0; --i) {
-            snapshot.addEdge(edges[i]);
-          }
-        }
-        virtual void clear() {
-          Edge edge;
-          for (notifier()->first(edge); edge != INVALID;
-               notifier()->next(edge)) {
-            snapshot.eraseEdge(edge);
-          }
-        }
-
-        Snapshot& snapshot;
-      };
-
-      ListBpGraph *graph;
-
-      NodeObserverProxy node_observer_proxy;
-      EdgeObserverProxy edge_observer_proxy;
-
-      std::list<Node> added_nodes;
-      std::list<Edge> added_edges;
-
-
-      void addNode(const Node& node) {
-        added_nodes.push_front(node);
-      }
-      void eraseNode(const Node& node) {
-        std::list<Node>::iterator it =
-          std::find(added_nodes.begin(), added_nodes.end(), node);
-        if (it == added_nodes.end()) {
-          clear();
-          edge_observer_proxy.detach();
-          throw NodeNotifier::ImmediateDetach();
-        } else {
-          added_nodes.erase(it);
-        }
-      }
-
-      void addEdge(const Edge& edge) {
-        added_edges.push_front(edge);
-      }
-      void eraseEdge(const Edge& edge) {
-        std::list<Edge>::iterator it =
-          std::find(added_edges.begin(), added_edges.end(), edge);
-        if (it == added_edges.end()) {
-          clear();
-          node_observer_proxy.detach();
-          throw EdgeNotifier::ImmediateDetach();
-        } else {
-          added_edges.erase(it);
-        }
-      }
-
-      void attach(ListBpGraph &_graph) {
-        graph = &_graph;
-        node_observer_proxy.attach(graph->notifier(Node()));
-        edge_observer_proxy.attach(graph->notifier(Edge()));
-      }
-
-      void detach() {
-        node_observer_proxy.detach();
-        edge_observer_proxy.detach();
-      }
-
-      bool attached() const {
-        return node_observer_proxy.attached();
-      }
-
-      void clear() {
-        added_nodes.clear();
-        added_edges.clear();
-      }
-
-    public:
-
-      /// \brief Default constructor.
-      ///
-      /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
-      Snapshot()
-        : graph(0), node_observer_proxy(*this),
-          edge_observer_proxy(*this) {}
-
-      /// \brief Constructor that immediately makes a snapshot.
-      ///
-      /// This constructor immediately makes a snapshot of the given graph.
-      Snapshot(ListBpGraph &gr)
-        : node_observer_proxy(*this),
-          edge_observer_proxy(*this) {
-        attach(gr);
-      }
-
-      /// \brief Make a snapshot.
-      ///
-      /// This function makes a snapshot of the given graph.
-      /// It can be called more than once. In case of a repeated
-      /// call, the previous snapshot gets lost.
-      void save(ListBpGraph &gr) {
-        if (attached()) {
-          detach();
-          clear();
-        }
-        attach(gr);
-      }
-
-      /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListBpGraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
-      void restore() {
-        detach();
-        for(std::list<Edge>::iterator it = added_edges.begin();
-            it != added_edges.end(); ++it) {
-          graph->erase(*it);
-        }
-        for(std::list<Node>::iterator it = added_nodes.begin();
-            it != added_nodes.end(); ++it) {
-          graph->erase(*it);
-        }
-        clear();
-      }
-
-      /// \brief Returns \c true if the snapshot is valid.
-      ///
-      /// This function returns \c true if the snapshot is valid.
-      bool valid() const {
-        return attached();
-      }
-    };
-  };
-
-  /// @}
 } //namespace lemon
 
Index: lemon/lp.h
===================================================================
--- lemon/lp.h	(revision 1232)
+++ lemon/lp.h	(revision 674)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -60,5 +60,5 @@
   ///\ingroup lp_group
   ///
-  ///Currently, the possible values are \c GLPK, \c CPLEX or \c CBC
+  ///Currently, the possible values are \c GLPK or \c CPLEX
 #define LEMON_DEFAULT_MIP SOLVER
   ///The default MIP solver.
@@ -67,22 +67,23 @@
   ///\ingroup lp_group
   ///
-  ///Currently, it is either \c GlpkMip, \c CplexMip , \c CbcMip
+  ///Currently, it is either \c GlpkMip or \c CplexMip
   typedef GlpkMip Mip;
 #else
-#if LEMON_DEFAULT_LP == GLPK
+#ifdef LEMON_HAVE_GLPK
+# define LEMON_DEFAULT_LP GLPK
   typedef GlpkLp Lp;
-#elif LEMON_DEFAULT_LP == CPLEX
+# define LEMON_DEFAULT_MIP GLPK
+  typedef GlpkMip Mip;
+#elif LEMON_HAVE_CPLEX
+# define LEMON_DEFAULT_LP CPLEX
   typedef CplexLp Lp;
-#elif LEMON_DEFAULT_LP == SOPLEX
+# define LEMON_DEFAULT_MIP CPLEX
+  typedef CplexMip Mip;
+#elif LEMON_HAVE_SOPLEX
+# define DEFAULT_LP SOPLEX
   typedef SoplexLp Lp;
-#elif LEMON_DEFAULT_LP == CLP
-  typedef ClpLp Lp;
-#endif
-#if LEMON_DEFAULT_MIP == GLPK
-  typedef GlpkLp Mip;
-#elif LEMON_DEFAULT_MIP == CPLEX
-  typedef CplexMip Mip;
-#elif LEMON_DEFAULT_MIP == CBC
-  typedef CbcMip Mip;
+#elif LEMON_HAVE_CLP
+# define DEFAULT_LP CLP
+  typedef ClpLp Lp;  
 #endif
 #endif
Index: lemon/lp_base.cc
===================================================================
--- lemon/lp_base.cc	(revision 956)
+++ lemon/lp_base.cc	(revision 557)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 1250)
+++ lemon/lp_base.h	(revision 1140)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -83,5 +83,5 @@
       MESSAGE_VERBOSE
     };
-
+    
 
     ///The floating point type used by the solver
@@ -115,12 +115,12 @@
       typedef True LpCol;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Col to an
       /// undefined value.
       Col() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Col to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Col(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -147,5 +147,5 @@
     ///Iterator for iterate over the columns of an LP problem
 
-    /// Its usage is quite simple, for example, you can count the number
+    /// Its usage is quite simple, for example you can count the number
     /// of columns in an LP \c lp:
     ///\code
@@ -157,10 +157,10 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       ColIt() {}
       /// Sets the iterator to the first Col
-
+      
       /// Sets the iterator to the first Col.
       ///
@@ -170,10 +170,10 @@
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       ColIt(const Invalid&) : Col(INVALID) {}
       /// Next column
-
+      
       /// Assign the iterator to the next column.
       ///
@@ -210,12 +210,12 @@
       typedef True LpRow;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Row to an
       /// undefined value.
       Row() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Row to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Row(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -225,5 +225,5 @@
       bool operator==(Row r) const  {return _id == r._id;}
       /// Inequality operator
-
+      
       /// \sa operator==(Row r)
       ///
@@ -242,5 +242,5 @@
     ///Iterator for iterate over the rows of an LP problem
 
-    /// Its usage is quite simple, for example, you can count the number
+    /// Its usage is quite simple, for example you can count the number
     /// of rows in an LP \c lp:
     ///\code
@@ -252,10 +252,10 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       RowIt() {}
       /// Sets the iterator to the first Row
-
+      
       /// Sets the iterator to the first Row.
       ///
@@ -265,10 +265,10 @@
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       RowIt(const Invalid&) : Row(INVALID) {}
       /// Next row
-
+      
       /// Assign the iterator to the next row.
       ///
@@ -348,5 +348,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients and
       /// the constant component are initialized to zero.
@@ -449,7 +449,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -465,5 +465,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -482,5 +482,5 @@
         const Value& operator*() const { return _it->second; }
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -494,7 +494,7 @@
 
       /// Const iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -510,5 +510,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -525,5 +525,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -674,5 +674,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients are
       /// initialized to zero.
@@ -709,5 +709,5 @@
       }
       /// \brief Removes the coefficients which's absolute value does
-      /// not exceed \c epsilon.
+      /// not exceed \c epsilon. 
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
@@ -758,7 +758,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -774,5 +774,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -792,5 +792,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -804,7 +804,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -820,5 +820,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -835,5 +835,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -944,12 +944,4 @@
     virtual int _addRow() = 0;
 
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-      int row = _addRow();
-      _setRowCoeffs(row, b, e);
-      _setRowLowerBound(row, l);
-      _setRowUpperBound(row, u);
-      return row;
-    }
-
     virtual void _eraseCol(int col) = 0;
     virtual void _eraseRow(int row) = 0;
@@ -1006,34 +998,4 @@
     LpBase() : rows(), cols(), obj_const_comp(0) {}
 
-  public:
-
-    ///\e \ 
-    class UnsupportedFormatError : public Exception
-    {
-      std::string _format;
-      mutable std::string _what;
-    public:
-      explicit UnsupportedFormatError(std::string format) throw()
-        : _format(format) { }
-      virtual ~UnsupportedFormatError() throw() {}
-      virtual const char* what() const throw() {
-        try {
-          _what.clear();
-          std::ostringstream oss;
-          oss << "lemon::UnsupportedFormatError: " << _format;
-          _what = oss.str();
-        }
-        catch (...) {}
-        if (!_what.empty()) return _what.c_str();
-        else return "lemon::UnsupportedFormatError";
-      }
-    };
-    
-  protected:
-    virtual void _write(std::string, std::string format) const
-    {
-      throw UnsupportedFormatError(format);
-    }
-    
   public:
 
@@ -1246,8 +1208,6 @@
     ///\return The created row.
     Row addRow(Value l,const Expr &e, Value u) {
-      Row r;
-      e.simplify();
-      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
-                                ExprIterator(e.comps.end(), cols), u - *e));
+      Row r=addRow();
+      row(r,l,e,u);
       return r;
     }
@@ -1258,10 +1218,6 @@
     ///\return The created row.
     Row addRow(const Constr &c) {
-      Row r;
-      c.expr().simplify();
-      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
-                                ExprIterator(c.expr().comps.begin(), cols),
-                                ExprIterator(c.expr().comps.end(), cols),
-                                c.upperBounded()?c.upperBound()-*c.expr():INF));
+      Row r=addRow();
+      row(r,c);
       return r;
     }
@@ -1586,24 +1542,9 @@
     void min() { _setSense(MIN); }
 
-    ///Clear the problem
+    ///Clears the problem
     void clear() { _clear(); rows.clear(); cols.clear(); }
 
-    /// Set the message level of the solver
+    /// Sets the message level of the solver
     void messageLevel(MessageLevel level) { _messageLevel(level); }
-
-    /// Write the problem to a file in the given format
-
-    /// This function writes the problem to a file in the given format.
-    /// Different solver backends may support different formats.
-    /// Trying to write in an unsupported format will trigger
-    /// \ref UnsupportedFormatError. For the supported formats,
-    /// visit the documentation of the base class of the related backends
-    /// (\ref CplexBase, \ref GlpkBase etc.)
-    /// \param file The file path
-    /// \param format The output file format.
-    void write(std::string file, std::string format = "MPS") const
-    {
-      _write(file.c_str(),format.c_str());
-    }
 
     ///@}
@@ -1863,8 +1804,8 @@
     enum VarStatus {
       /// The variable is in the basis
-      BASIC,
+      BASIC, 
       /// The variable is free, but not basic
       FREE,
-      /// The variable has active lower bound
+      /// The variable has active lower bound 
       LOWER,
       /// The variable has active upper bound
@@ -1945,5 +1886,5 @@
     }
     /// Returns a component of the primal ray
-
+    
     /// The primal ray is solution of the modified primal problem,
     /// where we change each finite bound to 0, and we looking for a
@@ -1979,5 +1920,5 @@
 
     /// Returns a component of the dual ray
-
+    
     /// The dual ray is solution of the modified primal problem, where
     /// we change each finite bound to 0 (i.e. the objective function
@@ -2121,5 +2062,5 @@
     }
     ///The value of the objective function
-
+    
     ///\return
     ///- \ref INF or -\ref INF means either infeasibility or unboundedness
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 1231)
+++ lemon/lp_skeleton.cc	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -29,9 +29,4 @@
 
   int SkeletonSolverBase::_addRow()
-  {
-    return ++row_num;
-  }
-
-  int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
   {
     return ++row_num;
@@ -92,6 +87,4 @@
   void SkeletonSolverBase::_messageLevel(MessageLevel) {}
 
-  void SkeletonSolverBase::_write(std::string, std::string) const {}
-
   LpSkeleton::SolveExitStatus LpSkeleton::_solve() { return SOLVED; }
 
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 1231)
+++ lemon/lp_skeleton.h	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,5 @@
 ///\file
 ///\brief Skeleton file to implement LP/MIP solver interfaces
-///
+///  
 ///The classes in this file do nothing, but they can serve as skeletons when
 ///implementing an interface to new solvers.
@@ -30,5 +30,5 @@
 
   ///A skeleton class to implement LP/MIP solver base interface
-
+  
   ///This class does nothing, but it can serve as a skeleton when
   ///implementing an interface to new solvers.
@@ -46,6 +46,4 @@
     virtual int _addRow();
     /// \e
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
-    /// \e
     virtual void _eraseCol(int i);
     /// \e
@@ -145,8 +143,4 @@
     ///\e
     virtual void _messageLevel(MessageLevel);
-
-    ///\e
-    virtual void _write(std::string file, std::string format) const;
-
   };
 
@@ -227,5 +221,4 @@
     ///\e
     virtual const char* _solverName() const;
-
   };
 
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 1057)
+++ lemon/maps.h	(revision 731)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -23,5 +23,4 @@
 #include <functional>
 #include <vector>
-#include <map>
 
 #include <lemon/core.h>
@@ -30,4 +29,6 @@
 ///\ingroup maps
 ///\brief Miscellaneous property maps
+
+#include <map>
 
 namespace lemon {
@@ -57,5 +58,5 @@
   /// but data written to it is not required (i.e. it will be sent to
   /// <tt>/dev/null</tt>).
-  /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   ///
   /// \sa ConstMap
@@ -90,5 +91,5 @@
   ///
   /// In other aspects it is equivalent to \c NullMap.
-  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
+  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
@@ -159,5 +160,5 @@
   ///
   /// In other aspects it is equivalent to \c NullMap.
-  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
+  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
@@ -231,7 +232,7 @@
   /// This map is essentially a wrapper for \c std::vector. It assigns
   /// values to integer keys from the range <tt>[0..size-1]</tt>.
-  /// It can be used together with some data structures, e.g.
-  /// heap types and \c UnionFind, when the used items are small
-  /// integers. This map conforms to the \ref concepts::ReferenceMap
+  /// It can be used with some data structures, for example
+  /// \c UnionFind, \c BinHeap, when the used items are small
+  /// integers. This map conforms the \ref concepts::ReferenceMap
   /// "ReferenceMap" concept.
   ///
@@ -341,5 +342,5 @@
   /// stored actually. This value can be different from the default
   /// contructed value (i.e. \c %Value()).
-  /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap"
+  /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"
   /// concept.
   ///
@@ -349,7 +350,7 @@
   /// The name of this type also refers to this important usage.
   ///
-  /// Apart form that, this map can be used in many other cases since it
+  /// Apart form that this map can be used in many other cases since it
   /// is based on \c std::map, which is a general associative container.
-  /// However, keep in mind that it is usually not as efficient as other
+  /// However keep in mind that it is usually not as efficient as other
   /// maps.
   ///
@@ -707,5 +708,5 @@
   /// The \c Key type of it is inherited from \c M and the \c Value
   /// type is \c V.
-  /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+  /// This type conforms the \ref concepts::ReadMap "ReadMap" concept.
   ///
   /// The simplest way of using this map is through the convertMap()
@@ -1786,13 +1787,13 @@
   /// The most important usage of it is storing certain nodes or arcs
   /// that were marked \c true by an algorithm.
-  /// For example, it makes easier to store the nodes in the processing
+  /// For example it makes easier to store the nodes in the processing
   /// order of Dfs algorithm, as the following examples show.
   /// \code
   ///   std::vector<Node> v;
-  ///   dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);
+  ///   dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run();
   /// \endcode
   /// \code
   ///   std::vector<Node> v(countNodes(g));
-  ///   dfs(g).processedMap(loggerBoolMap(v.begin())).run(s);
+  ///   dfs(g,s).processedMap(loggerBoolMap(v.begin())).run();
   /// \endcode
   ///
@@ -1801,5 +1802,5 @@
   ///
   /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
-  /// it cannot be used when a readable map is needed, for example, as
+  /// it cannot be used when a readable map is needed, for example as
   /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
   ///
@@ -1818,5 +1819,5 @@
   ///
   /// IdMap provides a unique and immutable id for each item of the
-  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
+  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 
   ///  - \b unique: different items get different ids,
   ///  - \b immutable: the id of an item does not change (even if you
@@ -1826,5 +1827,5 @@
   /// the items stored in the graph, which is returned by the \c id()
   /// function of the graph. This map can be inverted with its member
-  /// class \c InverseMap or with the \c operator()() member.
+  /// class \c InverseMap or with the \c operator() member.
   ///
   /// \tparam GR The graph type.
@@ -1866,9 +1867,7 @@
   public:
 
-    /// \brief The inverse map type of IdMap.
-    ///
-    /// The inverse map type of IdMap. The subscript operator gives back
-    /// an item by its id.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+    /// \brief This class represents the inverse of its owner (IdMap).
+    ///
+    /// This class represents the inverse of its owner (IdMap).
     /// \see inverse()
     class InverseMap {
@@ -1885,7 +1884,7 @@
       explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
 
-      /// \brief Gives back an item by its id.
+      /// \brief Gives back the given item from its id.
       ///
-      /// Gives back an item by its id.
+      /// Gives back the given item from its id.
       Item operator[](int id) const { return _graph->fromId(id, Item());}
 
@@ -1900,12 +1899,4 @@
   };
 
-  /// \brief Returns an \c IdMap class.
-  ///
-  /// This function just returns an \c IdMap class.
-  /// \relates IdMap
-  template <typename K, typename GR>
-  inline IdMap<GR, K> idMap(const GR& graph) {
-    return IdMap<GR, K>(graph);
-  }
 
   /// \brief General cross reference graph map type.
@@ -1914,15 +1905,6 @@
   /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)
   /// and if a key is set to a new value, then stores it in the inverse map.
-  /// The graph items can be accessed by their values either using
-  /// \c InverseMap or \c operator()(), and the values of the map can be
-  /// accessed with an STL compatible forward iterator (\c ValueIt).
-  ///
-  /// This map is intended to be used when all associated values are
-  /// different (the map is actually invertable) or there are only a few
-  /// items with the same value.
-  /// Otherwise consider to use \c IterableValueMap, which is more
-  /// suitable and more efficient for such cases. It provides iterators
-  /// to traverse the items with the same associated value, but
-  /// it does not have \c InverseMap.
+  /// The values of the map can be accessed
+  /// with stl compatible forward iterator.
   ///
   /// This type is not reference map, so it cannot be modified with
@@ -1965,38 +1947,31 @@
     /// \brief Forward iterator for values.
     ///
-    /// This iterator is an STL compatible forward
+    /// This iterator is an stl compatible forward
     /// iterator on the values of the map. The values can
     /// be accessed in the <tt>[beginValue, endValue)</tt> range.
     /// They are considered with multiplicity, so each value is
     /// traversed for each item it is assigned to.
-    class ValueIt
+    class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
       friend class CrossRefMap;
     private:
-      ValueIt(typename Container::const_iterator _it)
+      ValueIterator(typename Container::const_iterator _it)
         : it(_it) {}
     public:
 
-      /// Constructor
-      ValueIt() {}
-
-      /// \e
-      ValueIt& operator++() { ++it; return *this; }
-      /// \e
-      ValueIt operator++(int) {
-        ValueIt tmp(*this);
+      ValueIterator() {}
+
+      ValueIterator& operator++() { ++it; return *this; }
+      ValueIterator operator++(int) {
+        ValueIterator tmp(*this);
         operator++();
         return tmp;
       }
 
-      /// \e
       const Value& operator*() const { return it->first; }
-      /// \e
       const Value* operator->() const { return &(it->first); }
 
-      /// \e
-      bool operator==(ValueIt jt) const { return it == jt.it; }
-      /// \e
-      bool operator!=(ValueIt jt) const { return it != jt.it; }
+      bool operator==(ValueIterator jt) const { return it == jt.it; }
+      bool operator!=(ValueIterator jt) const { return it != jt.it; }
 
     private:
@@ -2004,25 +1979,22 @@
     };
 
-    /// Alias for \c ValueIt
-    typedef ValueIt ValueIterator;
-
     /// \brief Returns an iterator to the first value.
     ///
-    /// Returns an STL compatible iterator to the
+    /// Returns an stl compatible iterator to the
     /// first value of the map. The values of the
     /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
-    ValueIt beginValue() const {
-      return ValueIt(_inv_map.begin());
+    ValueIterator beginValue() const {
+      return ValueIterator(_inv_map.begin());
     }
 
     /// \brief Returns an iterator after the last value.
     ///
-    /// Returns an STL compatible iterator after the
+    /// Returns an stl compatible iterator after the
     /// last value of the map. The values of the
     /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
-    ValueIt endValue() const {
-      return ValueIt(_inv_map.end());
+    ValueIterator endValue() const {
+      return ValueIterator(_inv_map.end());
     }
 
@@ -2061,12 +2033,4 @@
       typename Container::const_iterator it = _inv_map.find(val);
       return it != _inv_map.end() ? it->second : INVALID;
-    }
-
-    /// \brief Returns the number of items with the given value.
-    ///
-    /// This function returns the number of items with the given value
-    /// associated with it.
-    int count(const Value &val) const {
-      return _inv_map.count(val);
     }
 
@@ -2120,10 +2084,8 @@
   public:
 
-    /// \brief The inverse map type of CrossRefMap.
-    ///
-    /// The inverse map type of CrossRefMap. The subscript operator gives
-    /// back an item by its value.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
-    /// \see inverse()
+    /// \brief The inverse map type.
+    ///
+    /// The inverse of this map. The subscript operator of the map
+    /// gives back the item that was last assigned to the value.
     class InverseMap {
     public:
@@ -2152,7 +2114,7 @@
     };
 
-    /// \brief Gives back the inverse of the map.
-    ///
-    /// Gives back the inverse of the CrossRefMap.
+    /// \brief It gives back the read-only inverse map.
+    ///
+    /// It gives back the read-only inverse map.
     InverseMap inverse() const {
       return InverseMap(*this);
@@ -2161,9 +2123,9 @@
   };
 
-  /// \brief Provides continuous and unique id for the
+  /// \brief Provides continuous and unique ID for the
   /// items of a graph.
   ///
   /// RangeIdMap provides a unique and continuous
-  /// id for each item of a given type (\c Node, \c Arc or
+  /// ID for each item of a given type (\c Node, \c Arc or
   /// \c Edge) in a graph. This id is
   ///  - \b unique: different items get different ids,
@@ -2176,5 +2138,5 @@
   /// the \c id() function of the graph or \ref IdMap.
   /// This map can be inverted with its member class \c InverseMap,
-  /// or with the \c operator()() member.
+  /// or with the \c operator() member.
   ///
   /// \tparam GR The graph type.
@@ -2304,14 +2266,14 @@
     }
 
-    /// \brief Gives back the \e range \e id of the item
-    ///
-    /// Gives back the \e range \e id of the item.
+    /// \brief Gives back the \e RangeId of the item
+    ///
+    /// Gives back the \e RangeId of the item.
     int operator[](const Item& item) const {
       return Map::operator[](item);
     }
 
-    /// \brief Gives back the item belonging to a \e range \e id
-    ///
-    /// Gives back the item belonging to the given \e range \e id.
+    /// \brief Gives back the item belonging to a \e RangeId
+    /// 
+    /// Gives back the item belonging to a \e RangeId.
     Item operator()(int id) const {
       return _inv_map[id];
@@ -2327,7 +2289,5 @@
     /// \brief The inverse map type of RangeIdMap.
     ///
-    /// The inverse map type of RangeIdMap. The subscript operator gives
-    /// back an item by its \e range \e id.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+    /// The inverse map type of RangeIdMap.
     class InverseMap {
     public:
@@ -2347,5 +2307,5 @@
       ///
       /// Subscript operator. It gives back the item
-      /// that the given \e range \e id currently belongs to.
+      /// that the descriptor currently belongs to.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2365,928 +2325,8 @@
     /// \brief Gives back the inverse of the map.
     ///
-    /// Gives back the inverse of the RangeIdMap.
+    /// Gives back the inverse of the map.
     const InverseMap inverse() const {
       return InverseMap(*this);
     }
-  };
-
-  /// \brief Returns a \c RangeIdMap class.
-  ///
-  /// This function just returns an \c RangeIdMap class.
-  /// \relates RangeIdMap
-  template <typename K, typename GR>
-  inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {
-    return RangeIdMap<GR, K>(graph);
-  }
-
-  /// \brief Dynamic iterable \c bool map.
-  ///
-  /// This class provides a special graph map type which can store a
-  /// \c bool value for graph items (\c Node, \c Arc or \c Edge).
-  /// For both \c true and \c false values it is possible to iterate on
-  /// the keys mapped to the value.
-  ///
-  /// This type is a reference map, so it can be modified with the
-  /// subscript operator.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IterableIntMap, IterableValueMap
-  /// \see CrossRefMap
-  template <typename GR, typename K>
-  class IterableBoolMap
-    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
-  private:
-    typedef GR Graph;
-
-    typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;
-    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;
-
-    std::vector<K> _array;
-    int _sep;
-
-  public:
-
-    /// Indicates that the map is reference map.
-    typedef True ReferenceMapTag;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef bool Value;
-    /// The const reference type.
-    typedef const Value& ConstReference;
-
-  private:
-
-    int position(const Key& key) const {
-      return Parent::operator[](key);
-    }
-
-  public:
-
-    /// \brief Reference to the value of the map.
-    ///
-    /// This class is similar to the \c bool type. It can be converted to
-    /// \c bool and it provides the same operators.
-    class Reference {
-      friend class IterableBoolMap;
-    private:
-      Reference(IterableBoolMap& map, const Key& key)
-        : _key(key), _map(map) {}
-    public:
-
-      Reference& operator=(const Reference& value) {
-        _map.set(_key, static_cast<bool>(value));
-         return *this;
-      }
-
-      operator bool() const {
-        return static_cast<const IterableBoolMap&>(_map)[_key];
-      }
-
-      Reference& operator=(bool value) {
-        _map.set(_key, value);
-        return *this;
-      }
-      Reference& operator&=(bool value) {
-        _map.set(_key, _map[_key] & value);
-        return *this;
-      }
-      Reference& operator|=(bool value) {
-        _map.set(_key, _map[_key] | value);
-        return *this;
-      }
-      Reference& operator^=(bool value) {
-        _map.set(_key, _map[_key] ^ value);
-        return *this;
-      }
-    private:
-      Key _key;
-      IterableBoolMap& _map;
-    };
-
-    /// \brief Constructor of the map with a default value.
-    ///
-    /// Constructor of the map with a default value.
-    explicit IterableBoolMap(const Graph& graph, bool def = false)
-      : Parent(graph) {
-      typename Parent::Notifier* nf = Parent::notifier();
-      Key it;
-      for (nf->first(it); it != INVALID; nf->next(it)) {
-        Parent::set(it, _array.size());
-        _array.push_back(it);
-      }
-      _sep = (def ? _array.size() : 0);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    bool operator[](const Key& key) const {
-      return position(key) < _sep;
-    }
-
-    /// \brief Subscript operator of the map.
-    ///
-    /// Subscript operator of the map.
-    Reference operator[](const Key& key) {
-      return Reference(*this, key);
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, bool value) {
-      int pos = position(key);
-      if (value) {
-        if (pos < _sep) return;
-        Key tmp = _array[_sep];
-        _array[_sep] = key;
-        Parent::set(key, _sep);
-        _array[pos] = tmp;
-        Parent::set(tmp, pos);
-        ++_sep;
-      } else {
-        if (pos >= _sep) return;
-        --_sep;
-        Key tmp = _array[_sep];
-        _array[_sep] = key;
-        Parent::set(key, _sep);
-        _array[pos] = tmp;
-        Parent::set(tmp, pos);
-      }
-    }
-
-    /// \brief Set all items.
-    ///
-    /// Set all items in the map.
-    /// \note Constant time operation.
-    void setAll(bool value) {
-      _sep = (value ? _array.size() : 0);
-    }
-
-    /// \brief Returns the number of the keys mapped to \c true.
-    ///
-    /// Returns the number of the keys mapped to \c true.
-    int trueNum() const {
-      return _sep;
-    }
-
-    /// \brief Returns the number of the keys mapped to \c false.
-    ///
-    /// Returns the number of the keys mapped to \c false.
-    int falseNum() const {
-      return _array.size() - _sep;
-    }
-
-    /// \brief Iterator for the keys mapped to \c true.
-    ///
-    /// Iterator for the keys mapped to \c true. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class TrueIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator.
-      ///
-      /// Creates an iterator. It iterates on the
-      /// keys mapped to \c true.
-      /// \param map The IterableBoolMap.
-      explicit TrueIt(const IterableBoolMap& map)
-        : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),
-          _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      TrueIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      TrueIt& operator++() {
-        int pos = _map->position(*this);
-        Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-    /// \brief Iterator for the keys mapped to \c false.
-    ///
-    /// Iterator for the keys mapped to \c false. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class FalseIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator.
-      ///
-      /// Creates an iterator. It iterates on the
-      /// keys mapped to \c false.
-      /// \param map The IterableBoolMap.
-      explicit FalseIt(const IterableBoolMap& map)
-        : Parent(map._sep < int(map._array.size()) ?
-                 map._array.back() : INVALID), _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      FalseIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      FalseIt& operator++() {
-        int pos = _map->position(*this);
-        Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-    /// \brief Iterator for the keys mapped to a given value.
-    ///
-    /// Iterator for the keys mapped to a given value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys mapped to the given value.
-      /// \param map The IterableBoolMap.
-      /// \param value The value.
-      ItemIt(const IterableBoolMap& map, bool value)
-        : Parent(value ?
-                 (map._sep > 0 ?
-                  map._array[map._sep - 1] : INVALID) :
-                 (map._sep < int(map._array.size()) ?
-                  map._array.back() : INVALID)), _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ItemIt& operator++() {
-        int pos = _map->position(*this);
-        int _sep = pos >= _map->_sep ? _map->_sep : 0;
-        Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-  protected:
-
-    virtual void add(const Key& key) {
-      Parent::add(key);
-      Parent::set(key, _array.size());
-      _array.push_back(key);
-    }
-
-    virtual void add(const std::vector<Key>& keys) {
-      Parent::add(keys);
-      for (int i = 0; i < int(keys.size()); ++i) {
-        Parent::set(keys[i], _array.size());
-        _array.push_back(keys[i]);
-      }
-    }
-
-    virtual void erase(const Key& key) {
-      int pos = position(key);
-      if (pos < _sep) {
-        --_sep;
-        Parent::set(_array[_sep], pos);
-        _array[pos] = _array[_sep];
-        Parent::set(_array.back(), _sep);
-        _array[_sep] = _array.back();
-        _array.pop_back();
-      } else {
-        Parent::set(_array.back(), pos);
-        _array[pos] = _array.back();
-        _array.pop_back();
-      }
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        int pos = position(keys[i]);
-        if (pos < _sep) {
-          --_sep;
-          Parent::set(_array[_sep], pos);
-          _array[pos] = _array[_sep];
-          Parent::set(_array.back(), _sep);
-          _array[_sep] = _array.back();
-          _array.pop_back();
-        } else {
-          Parent::set(_array.back(), pos);
-          _array[pos] = _array.back();
-          _array.pop_back();
-        }
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void build() {
-      Parent::build();
-      typename Parent::Notifier* nf = Parent::notifier();
-      Key it;
-      for (nf->first(it); it != INVALID; nf->next(it)) {
-        Parent::set(it, _array.size());
-        _array.push_back(it);
-      }
-      _sep = 0;
-    }
-
-    virtual void clear() {
-      _array.clear();
-      _sep = 0;
-      Parent::clear();
-    }
-
-  };
-
-
-  namespace _maps_bits {
-    template <typename Item>
-    struct IterableIntMapNode {
-      IterableIntMapNode() : value(-1) {}
-      IterableIntMapNode(int _value) : value(_value) {}
-      Item prev, next;
-      int value;
-    };
-  }
-
-  /// \brief Dynamic iterable integer map.
-  ///
-  /// This class provides a special graph map type which can store an
-  /// integer value for graph items (\c Node, \c Arc or \c Edge).
-  /// For each non-negative value it is possible to iterate on the keys
-  /// mapped to the value.
-  ///
-  /// This map is intended to be used with small integer values, for which
-  /// it is efficient, and supports iteration only for non-negative values.
-  /// If you need large values and/or iteration for negative integers,
-  /// consider to use \ref IterableValueMap instead.
-  ///
-  /// This type is a reference map, so it can be modified with the
-  /// subscript operator.
-  ///
-  /// \note The size of the data structure depends on the largest
-  /// value in the map.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IterableBoolMap, IterableValueMap
-  /// \see CrossRefMap
-  template <typename GR, typename K>
-  class IterableIntMap
-    : protected ItemSetTraits<GR, K>::
-        template Map<_maps_bits::IterableIntMapNode<K> >::Type {
-  public:
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<_maps_bits::IterableIntMapNode<K> >::Type Parent;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef int Value;
-    /// The graph type
-    typedef GR Graph;
-
-    /// \brief Constructor of the map.
-    ///
-    /// Constructor of the map. It sets all values to -1.
-    explicit IterableIntMap(const Graph& graph)
-      : Parent(graph) {}
-
-    /// \brief Constructor of the map with a given value.
-    ///
-    /// Constructor of the map with a given value.
-    explicit IterableIntMap(const Graph& graph, int value)
-      : Parent(graph, _maps_bits::IterableIntMapNode<K>(value)) {
-      if (value >= 0) {
-        for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-          lace(it);
-        }
-      }
-    }
-
-  private:
-
-    void unlace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.value < 0) return;
-      if (node.prev != INVALID) {
-        Parent::operator[](node.prev).next = node.next;
-      } else {
-        _first[node.value] = node.next;
-      }
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = node.prev;
-      }
-      while (!_first.empty() && _first.back() == INVALID) {
-        _first.pop_back();
-      }
-    }
-
-    void lace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.value < 0) return;
-      if (node.value >= int(_first.size())) {
-        _first.resize(node.value + 1, INVALID);
-      }
-      node.prev = INVALID;
-      node.next = _first[node.value];
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = key;
-      }
-      _first[node.value] = key;
-    }
-
-  public:
-
-    /// Indicates that the map is reference map.
-    typedef True ReferenceMapTag;
-
-    /// \brief Reference to the value of the map.
-    ///
-    /// This class is similar to the \c int type. It can
-    /// be converted to \c int and it has the same operators.
-    class Reference {
-      friend class IterableIntMap;
-    private:
-      Reference(IterableIntMap& map, const Key& key)
-        : _key(key), _map(map) {}
-    public:
-
-      Reference& operator=(const Reference& value) {
-        _map.set(_key, static_cast<const int&>(value));
-         return *this;
-      }
-
-      operator const int&() const {
-        return static_cast<const IterableIntMap&>(_map)[_key];
-      }
-
-      Reference& operator=(int value) {
-        _map.set(_key, value);
-        return *this;
-      }
-      Reference& operator++() {
-        _map.set(_key, _map[_key] + 1);
-        return *this;
-      }
-      int operator++(int) {
-        int value = _map[_key];
-        _map.set(_key, value + 1);
-        return value;
-      }
-      Reference& operator--() {
-        _map.set(_key, _map[_key] - 1);
-        return *this;
-      }
-      int operator--(int) {
-        int value = _map[_key];
-        _map.set(_key, value - 1);
-        return value;
-      }
-      Reference& operator+=(int value) {
-        _map.set(_key, _map[_key] + value);
-        return *this;
-      }
-      Reference& operator-=(int value) {
-        _map.set(_key, _map[_key] - value);
-        return *this;
-      }
-      Reference& operator*=(int value) {
-        _map.set(_key, _map[_key] * value);
-        return *this;
-      }
-      Reference& operator/=(int value) {
-        _map.set(_key, _map[_key] / value);
-        return *this;
-      }
-      Reference& operator%=(int value) {
-        _map.set(_key, _map[_key] % value);
-        return *this;
-      }
-      Reference& operator&=(int value) {
-        _map.set(_key, _map[_key] & value);
-        return *this;
-      }
-      Reference& operator|=(int value) {
-        _map.set(_key, _map[_key] | value);
-        return *this;
-      }
-      Reference& operator^=(int value) {
-        _map.set(_key, _map[_key] ^ value);
-        return *this;
-      }
-      Reference& operator<<=(int value) {
-        _map.set(_key, _map[_key] << value);
-        return *this;
-      }
-      Reference& operator>>=(int value) {
-        _map.set(_key, _map[_key] >> value);
-        return *this;
-      }
-
-    private:
-      Key _key;
-      IterableIntMap& _map;
-    };
-
-    /// The const reference type.
-    typedef const Value& ConstReference;
-
-    /// \brief Gives back the maximal value plus one.
-    ///
-    /// Gives back the maximal value plus one.
-    int size() const {
-      return _first.size();
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, const Value& value) {
-      unlace(key);
-      Parent::operator[](key).value = value;
-      lace(key);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    const Value& operator[](const Key& key) const {
-      return Parent::operator[](key).value;
-    }
-
-    /// \brief Subscript operator of the map.
-    ///
-    /// Subscript operator of the map.
-    Reference operator[](const Key& key) {
-      return Reference(*this, key);
-    }
-
-    /// \brief Iterator for the keys with the same value.
-    ///
-    /// Iterator for the keys with the same value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the item type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid item, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys mapped to the given value.
-      /// \param map The IterableIntMap.
-      /// \param value The value.
-      ItemIt(const IterableIntMap& map, int value) : _map(&map) {
-        if (value < 0 || value >= int(_map->_first.size())) {
-          Parent::operator=(INVALID);
-        } else {
-          Parent::operator=(_map->_first[value]);
-        }
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ItemIt& operator++() {
-        Parent::operator=(_map->IterableIntMap::Parent::
-                          operator[](static_cast<Parent&>(*this)).next);
-        return *this;
-      }
-
-    private:
-      const IterableIntMap* _map;
-    };
-
-  protected:
-
-    virtual void erase(const Key& key) {
-      unlace(key);
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        unlace(keys[i]);
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void clear() {
-      _first.clear();
-      Parent::clear();
-    }
-
-  private:
-    std::vector<Key> _first;
-  };
-
-  namespace _maps_bits {
-    template <typename Item, typename Value>
-    struct IterableValueMapNode {
-      IterableValueMapNode(Value _value = Value()) : value(_value) {}
-      Item prev, next;
-      Value value;
-    };
-  }
-
-  /// \brief Dynamic iterable map for comparable values.
-  ///
-  /// This class provides a special graph map type which can store a
-  /// comparable value for graph items (\c Node, \c Arc or \c Edge).
-  /// For each value it is possible to iterate on the keys mapped to
-  /// the value (\c ItemIt), and the values of the map can be accessed
-  /// with an STL compatible forward iterator (\c ValueIt).
-  /// The map stores a linked list for each value, which contains
-  /// the items mapped to the value, and the used values are stored
-  /// in balanced binary tree (\c std::map).
-  ///
-  /// \ref IterableBoolMap and \ref IterableIntMap are similar classes
-  /// specialized for \c bool and \c int values, respectively.
-  ///
-  /// This type is not reference map, so it cannot be modified with
-  /// the subscript operator.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  /// \tparam V The value type of the map. It can be any comparable
-  /// value type.
-  ///
-  /// \see IterableBoolMap, IterableIntMap
-  /// \see CrossRefMap
-  template <typename GR, typename K, typename V>
-  class IterableValueMap
-    : protected ItemSetTraits<GR, K>::
-        template Map<_maps_bits::IterableValueMapNode<K, V> >::Type {
-  public:
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<_maps_bits::IterableValueMapNode<K, V> >::Type Parent;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef V Value;
-    /// The graph type
-    typedef GR Graph;
-
-  public:
-
-    /// \brief Constructor of the map with a given value.
-    ///
-    /// Constructor of the map with a given value.
-    explicit IterableValueMap(const Graph& graph,
-                              const Value& value = Value())
-      : Parent(graph, _maps_bits::IterableValueMapNode<K, V>(value)) {
-      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-        lace(it);
-      }
-    }
-
-  protected:
-
-    void unlace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.prev != INVALID) {
-        Parent::operator[](node.prev).next = node.next;
-      } else {
-        if (node.next != INVALID) {
-          _first[node.value] = node.next;
-        } else {
-          _first.erase(node.value);
-        }
-      }
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = node.prev;
-      }
-    }
-
-    void lace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      typename std::map<Value, Key>::iterator it = _first.find(node.value);
-      if (it == _first.end()) {
-        node.prev = node.next = INVALID;
-        _first.insert(std::make_pair(node.value, key));
-      } else {
-        node.prev = INVALID;
-        node.next = it->second;
-        if (node.next != INVALID) {
-          Parent::operator[](node.next).prev = key;
-        }
-        it->second = key;
-      }
-    }
-
-  public:
-
-    /// \brief Forward iterator for values.
-    ///
-    /// This iterator is an STL compatible forward
-    /// iterator on the values of the map. The values can
-    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
-    class ValueIt
-      : public std::iterator<std::forward_iterator_tag, Value> {
-      friend class IterableValueMap;
-    private:
-      ValueIt(typename std::map<Value, Key>::const_iterator _it)
-        : it(_it) {}
-    public:
-
-      /// Constructor
-      ValueIt() {}
-
-      /// \e
-      ValueIt& operator++() { ++it; return *this; }
-      /// \e
-      ValueIt operator++(int) {
-        ValueIt tmp(*this);
-        operator++();
-        return tmp;
-      }
-
-      /// \e
-      const Value& operator*() const { return it->first; }
-      /// \e
-      const Value* operator->() const { return &(it->first); }
-
-      /// \e
-      bool operator==(ValueIt jt) const { return it == jt.it; }
-      /// \e
-      bool operator!=(ValueIt jt) const { return it != jt.it; }
-
-    private:
-      typename std::map<Value, Key>::const_iterator it;
-    };
-
-    /// \brief Returns an iterator to the first value.
-    ///
-    /// Returns an STL compatible iterator to the
-    /// first value of the map. The values of the
-    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
-    /// range.
-    ValueIt beginValue() const {
-      return ValueIt(_first.begin());
-    }
-
-    /// \brief Returns an iterator after the last value.
-    ///
-    /// Returns an STL compatible iterator after the
-    /// last value of the map. The values of the
-    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
-    /// range.
-    ValueIt endValue() const {
-      return ValueIt(_first.end());
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, const Value& value) {
-      unlace(key);
-      Parent::operator[](key).value = value;
-      lace(key);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    const Value& operator[](const Key& key) const {
-      return Parent::operator[](key).value;
-    }
-
-    /// \brief Iterator for the keys with the same value.
-    ///
-    /// Iterator for the keys with the same value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the item type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid item, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys which have the given value.
-      /// \param map The IterableValueMap
-      /// \param value The value
-      ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {
-        typename std::map<Value, Key>::const_iterator it =
-          map._first.find(value);
-        if (it == map._first.end()) {
-          Parent::operator=(INVALID);
-        } else {
-          Parent::operator=(it->second);
-        }
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment Operator.
-      ItemIt& operator++() {
-        Parent::operator=(_map->IterableValueMap::Parent::
-                          operator[](static_cast<Parent&>(*this)).next);
-        return *this;
-      }
-
-
-    private:
-      const IterableValueMap* _map;
-    };
-
-  protected:
-
-    virtual void add(const Key& key) {
-      Parent::add(key);
-      lace(key);
-    }
-
-    virtual void add(const std::vector<Key>& keys) {
-      Parent::add(keys);
-      for (int i = 0; i < int(keys.size()); ++i) {
-        lace(keys[i]);
-      }
-    }
-
-    virtual void erase(const Key& key) {
-      unlace(key);
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        unlace(keys[i]);
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void build() {
-      Parent::build();
-      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-        lace(it);
-      }
-    }
-
-    virtual void clear() {
-      _first.clear();
-      Parent::clear();
-    }
-
-  private:
-    std::map<Value, Key> _first;
   };
 
@@ -3301,7 +2341,7 @@
   public:
 
-    /// The key type (the \c Arc type of the digraph).
+    ///\e
     typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
+    ///\e
     typedef typename GR::Node Value;
 
@@ -3342,7 +2382,7 @@
   public:
 
-    /// The key type (the \c Arc type of the digraph).
+    ///\e
     typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
+    ///\e
     typedef typename GR::Node Value;
 
@@ -3384,8 +2424,6 @@
   public:
 
-    /// The key type (the \c Edge type of the digraph).
+    typedef typename GR::Arc Value;
     typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
 
     /// \brief Constructor
@@ -3426,8 +2464,6 @@
   public:
 
-    /// The key type (the \c Edge type of the digraph).
+    typedef typename GR::Arc Value;
     typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
 
     /// \brief Constructor
@@ -3464,8 +2500,8 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of InDegMap is not guarantied if these additional
-  /// features are used. For example, the functions
+  /// features are used. For example the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
@@ -3480,5 +2516,5 @@
 
   public:
-
+    
     /// The graph type of InDegMap
     typedef GR Graph;
@@ -3594,8 +2630,8 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of OutDegMap is not guarantied if these additional
-  /// features are used. For example, the functions
+  /// features are used. For example the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
@@ -3765,291 +2801,4 @@
   }
 
-
-  /// \brief Copy the values of a graph map to another map.
-  ///
-  /// This function copies the values of a graph map to another graph map.
-  /// \c To::Key must be equal or convertible to \c From::Key and
-  /// \c From::Value must be equal or convertible to \c To::Value.
-  ///
-  /// For example, an edge map of \c int value type can be copied to
-  /// an arc map of \c double value type in an undirected graph, but
-  /// an arc map cannot be copied to an edge map.
-  /// Note that even a \ref ConstMap can be copied to a standard graph map,
-  /// but \ref mapFill() can also be used for this purpose.
-  ///
-  /// \param gr The graph for which the maps are defined.
-  /// \param from The map from which the values have to be copied.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-  /// \param to The map to which the values have to be copied.
-  /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-  template <typename GR, typename From, typename To>
-  void mapCopy(const GR& gr, const From& from, To& to) {
-    typedef typename To::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      to.set(it, from[it]);
-    }
-  }
-
-  /// \brief Compare two graph maps.
-  ///
-  /// This function compares the values of two graph maps. It returns
-  /// \c true if the maps assign the same value for all items in the graph.
-  /// The \c Key type of the maps (\c Node, \c Arc or \c Edge) must be equal
-  /// and their \c Value types must be comparable using \c %operator==().
-  ///
-  /// \param gr The graph for which the maps are defined.
-  /// \param map1 The first map.
-  /// \param map2 The second map.
-  template <typename GR, typename Map1, typename Map2>
-  bool mapCompare(const GR& gr, const Map1& map1, const Map2& map2) {
-    typedef typename Map2::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (!(map1[it] == map2[it])) return false;
-    }
-    return true;
-  }
-
-  /// \brief Return an item having minimum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// minimum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Key mapMin(const GR& gr, const Map& map) {
-    return mapMin(gr, map, std::less<typename Map::Value>());
-  }
-
-  /// \brief Return an item having minimum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// minimum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Key mapMin(const GR& gr, const Map& map, const Comp& comp) {
-    typedef typename Map::Key Item;
-    typedef typename Map::Value Value;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    ItemIt min_item(gr);
-    if (min_item == INVALID) return INVALID;
-    Value min = map[min_item];
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (comp(map[it], min)) {
-        min = map[it];
-        min_item = it;
-      }
-    }
-    return min_item;
-  }
-
-  /// \brief Return an item having maximum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// maximum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Key mapMax(const GR& gr, const Map& map) {
-    return mapMax(gr, map, std::less<typename Map::Value>());
-  }
-
-  /// \brief Return an item having maximum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// maximum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Key mapMax(const GR& gr, const Map& map, const Comp& comp) {
-    typedef typename Map::Key Item;
-    typedef typename Map::Value Value;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    ItemIt max_item(gr);
-    if (max_item == INVALID) return INVALID;
-    Value max = map[max_item];
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (comp(max, map[it])) {
-        max = map[it];
-        max_item = it;
-      }
-    }
-    return max_item;
-  }
-
-  /// \brief Return the minimum value of a graph map.
-  ///
-  /// This function returns the minimum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Value mapMinValue(const GR& gr, const Map& map) {
-    return map[mapMin(gr, map, std::less<typename Map::Value>())];
-  }
-
-  /// \brief Return the minimum value of a graph map.
-  ///
-  /// This function returns the minimum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Value
-  mapMinValue(const GR& gr, const Map& map, const Comp& comp) {
-    return map[mapMin(gr, map, comp)];
-  }
-
-  /// \brief Return the maximum value of a graph map.
-  ///
-  /// This function returns the maximum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Value mapMaxValue(const GR& gr, const Map& map) {
-    return map[mapMax(gr, map, std::less<typename Map::Value>())];
-  }
-
-  /// \brief Return the maximum value of a graph map.
-  ///
-  /// This function returns the maximum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Value
-  mapMaxValue(const GR& gr, const Map& map, const Comp& comp) {
-    return map[mapMax(gr, map, comp)];
-  }
-
-  /// \brief Return an item having a specified value in a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// the specified assigned value in the given graph map.
-  /// If no such item exists, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param val The value that have to be found.
-  template <typename GR, typename Map>
-  typename Map::Key
-  mapFind(const GR& gr, const Map& map, const typename Map::Value& val) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (map[it] == val) return it;
-    }
-    return INVALID;
-  }
-
-  /// \brief Return an item having value for which a certain predicate is
-  /// true in a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// such assigned value for which the specified predicate is true
-  /// in the given graph map.
-  /// If no such item exists, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param pred The predicate function object.
-  template <typename GR, typename Map, typename Pred>
-  typename Map::Key
-  mapFindIf(const GR& gr, const Map& map, const Pred& pred) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (pred(map[it])) return it;
-    }
-    return INVALID;
-  }
-
-  /// \brief Return the number of items having a specified value in a
-  /// graph map.
-  ///
-  /// This function returns the number of items (\c Node, \c Arc or \c Edge)
-  /// having the specified assigned value in the given graph map.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param val The value that have to be counted.
-  template <typename GR, typename Map>
-  int mapCount(const GR& gr, const Map& map, const typename Map::Value& val) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    int cnt = 0;
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (map[it] == val) ++cnt;
-    }
-    return cnt;
-  }
-
-  /// \brief Return the number of items having values for which a certain
-  /// predicate is true in a graph map.
-  ///
-  /// This function returns the number of items (\c Node, \c Arc or \c Edge)
-  /// having such assigned values for which the specified predicate is true
-  /// in the given graph map.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param pred The predicate function object.
-  template <typename GR, typename Map, typename Pred>
-  int mapCountIf(const GR& gr, const Map& map, const Pred& pred) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    int cnt = 0;
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (pred(map[it])) ++cnt;
-    }
-    return cnt;
-  }
-
-  /// \brief Fill a graph map with a certain value.
-  ///
-  /// This function sets the specified value for all items (\c Node,
-  /// \c Arc or \c Edge) in the given graph map.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map. It must conform to the
-  /// \ref concepts::WriteMap "WriteMap" concept.
-  /// \param val The value.
-  template <typename GR, typename Map>
-  void mapFill(const GR& gr, Map& map, const typename Map::Value& val) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      map.set(it, val);
-    }
-  }
-
   /// @}
 }
Index: lemon/matching.h
===================================================================
--- lemon/matching.h	(revision 956)
+++ lemon/matching.h	(revision 945)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_MATCHING_H
-#define LEMON_MATCHING_H
+#ifndef LEMON_MAX_MATCHING_H
+#define LEMON_MAX_MATCHING_H
 
 #include <vector>
@@ -29,5 +29,4 @@
 #include <lemon/bin_heap.h>
 #include <lemon/maps.h>
-#include <lemon/fractional_matching.h>
 
 ///\ingroup matching
@@ -43,5 +42,5 @@
   /// This class implements Edmonds' alternating forest matching algorithm
   /// for finding a maximum cardinality matching in a general undirected graph.
-  /// It can be started from an arbitrary initial matching
+  /// It can be started from an arbitrary initial matching 
   /// (the default is the empty one).
   ///
@@ -71,9 +70,9 @@
     ///\brief Status constants for Gallai-Edmonds decomposition.
     ///
-    ///These constants are used for indicating the Gallai-Edmonds
+    ///These constants are used for indicating the Gallai-Edmonds 
     ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
     ///induce a subgraph with factor-critical components, the nodes with
     ///status \c ODD (or \c A) form the canonical barrier, and the nodes
-    ///with status \c MATCHED (or \c C) induce a subgraph having a
+    ///with status \c MATCHED (or \c C) induce a subgraph having a 
     ///perfect matching.
     enum Status {
@@ -514,5 +513,5 @@
     }
 
-    /// \brief Start Edmonds' algorithm with a heuristic improvement
+    /// \brief Start Edmonds' algorithm with a heuristic improvement 
     /// for dense graphs
     ///
@@ -536,6 +535,6 @@
     /// \brief Run Edmonds' algorithm
     ///
-    /// This function runs Edmonds' algorithm. An additional heuristic of
-    /// postponing shrinks is used for relatively dense graphs
+    /// This function runs Edmonds' algorithm. An additional heuristic of 
+    /// postponing shrinks is used for relatively dense graphs 
     /// (for which <tt>m>=2*n</tt> holds).
     void run() {
@@ -558,5 +557,5 @@
     /// \brief Return the size (cardinality) of the matching.
     ///
-    /// This function returns the size (cardinality) of the current matching.
+    /// This function returns the size (cardinality) of the current matching. 
     /// After run() it returns the size of the maximum matching in the graph.
     int matchingSize() const {
@@ -572,5 +571,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the current
+    /// This function returns \c true if the given edge is in the current 
     /// matching.
     bool matching(const Edge& edge) const {
@@ -581,5 +580,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the current matching or \c INVALID if the node is
+    /// given node in the current matching or \c INVALID if the node is 
     /// not covered by the matching.
     Arc matching(const Node& n) const {
@@ -597,5 +596,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the current
+    /// This function returns the mate of the given node in the current 
     /// matching or \c INVALID if the node is not covered by the matching.
     Node mate(const Node& n) const {
@@ -607,5 +606,5 @@
 
     /// \name Dual Solution
-    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
+    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
     /// decomposition.
 
@@ -650,6 +649,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted matching problem is to find a subset of the
-  /// edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted matching problem is to find a subset of the 
+  /// edges in an undirected graph with maximum overall weight for which 
   /// each node has at most one incident edge.
   /// It can be formulated with the following linear program.
@@ -675,14 +674,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -747,5 +746,5 @@
 
     enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
+      EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2
     };
 
@@ -799,8 +798,4 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedFractionalMatching<Graph, WeightMap> FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -869,4 +864,7 @@
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -944,5 +942,205 @@
               _delta3->push(e, rw / 2);
             }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
           } else {
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              if ((*_node_data)[vi].heap[it->second] > rw) {
+                (*_node_data)[vi].heap.replace(it->second, e);
+                (*_node_data)[vi].heap.decrease(e, rw);
+                it->second = e;
+              }
+            } else {
+              (*_node_data)[vi].heap.push(e, rw);
+              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
+            }
+
+            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
+              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_delta2->state(vb) != _delta2->IN_HEAP) {
+                  _delta2->push(vb, _blossom_set->classPrio(vb) -
+                               (*_blossom_data)[vb].offset);
+                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset){
+                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+      (*_blossom_data)[blossom].offset = 0;
+    }
+
+    void matchedToOdd(int blossom) {
+      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
+        _delta2->erase(blossom);
+      }
+      (*_blossom_data)[blossom].offset += _delta_sum;
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
+                     (*_blossom_data)[blossom].offset);
+      }
+    }
+
+    void evenToMatched(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+        (*_node_data)[ni].pot -= _delta_sum;
+
+        _delta1->erase(n);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if (vb == blossom) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else if ((*_blossom_data)[vb].status == EVEN) {
+
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+
+            int vt = _tree_set->find(vb);
+
+            if (vt != tree) {
+
+              Arc r = _graph.oppositeArc(e);
+
+              typename std::map<int, Arc>::iterator it =
+                (*_node_data)[ni].heap_index.find(vt);
+
+              if (it != (*_node_data)[ni].heap_index.end()) {
+                if ((*_node_data)[ni].heap[it->second] > rw) {
+                  (*_node_data)[ni].heap.replace(it->second, r);
+                  (*_node_data)[ni].heap.decrease(r, rw);
+                  it->second = r;
+                }
+              } else {
+                (*_node_data)[ni].heap.push(r, rw);
+                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+              }
+
+              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                               (*_blossom_data)[blossom].offset);
+                } else if ((*_delta2)[blossom] >
+                           _blossom_set->classPrio(blossom) -
+                           (*_blossom_data)[blossom].offset){
+                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                   (*_blossom_data)[blossom].offset);
+                }
+              }
+            }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else {
+
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              (*_node_data)[vi].heap.erase(it->second);
+              (*_node_data)[vi].heap_index.erase(it);
+              if ((*_node_data)[vi].heap.empty()) {
+                _blossom_set->increase(v, std::numeric_limits<Value>::max());
+              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
+                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
+              }
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_blossom_set->classPrio(vb) ==
+                    std::numeric_limits<Value>::max()) {
+                  _delta2->erase(vb);
+                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset) {
+                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    void oddToMatched(int blossom) {
+      (*_blossom_data)[blossom].offset -= _delta_sum;
+
+      if (_blossom_set->classPrio(blossom) !=
+          std::numeric_limits<Value>::max()) {
+        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                       (*_blossom_data)[blossom].offset);
+      }
+
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+      }
+    }
+
+    void oddToEven(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+        (*_blossom_data)[blossom].pot -=
+          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+        (*_node_data)[ni].pot +=
+          2 * _delta_sum - (*_blossom_data)[blossom].offset;
+
+        _delta1->push(n, (*_node_data)[ni].pot);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
+              _delta3->push(e, rw / 2);
+            }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          } else {
+
             typename std::map<int, Arc>::iterator it =
               (*_node_data)[vi].heap_index.find(tree);
@@ -979,18 +1177,8 @@
     }
 
-    void matchedToOdd(int blossom) {
+
+    void matchedToUnmatched(int blossom) {
       if (_delta2->state(blossom) == _delta2->IN_HEAP) {
         _delta2->erase(blossom);
-      }
-      (*_blossom_data)[blossom].offset += _delta_sum;
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
-                      (*_blossom_data)[blossom].offset);
-      }
-    }
-
-    void evenToMatched(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
       }
 
@@ -998,7 +1186,31 @@
            n != INVALID; ++n) {
         int ni = (*_node_index)[n];
-        (*_node_data)[ni].pot -= _delta_sum;
-
-        _delta1->erase(n);
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+
+        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.target(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          }
+        }
+      }
+    }
+
+    void unmatchedToMatched(int blossom) {
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
 
         for (InArcIt e(_graph, n); e != INVALID; ++e) {
@@ -1022,146 +1234,40 @@
             int vt = _tree_set->find(vb);
 
-            if (vt != tree) {
-
-              Arc r = _graph.oppositeArc(e);
-
-              typename std::map<int, Arc>::iterator it =
-                (*_node_data)[ni].heap_index.find(vt);
-
-              if (it != (*_node_data)[ni].heap_index.end()) {
-                if ((*_node_data)[ni].heap[it->second] > rw) {
-                  (*_node_data)[ni].heap.replace(it->second, r);
-                  (*_node_data)[ni].heap.decrease(r, rw);
-                  it->second = r;
-                }
-              } else {
-                (*_node_data)[ni].heap.push(r, rw);
-                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
-              }
-
-              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
-                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-
-                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
-                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                               (*_blossom_data)[blossom].offset);
-                } else if ((*_delta2)[blossom] >
-                           _blossom_set->classPrio(blossom) -
-                           (*_blossom_data)[blossom].offset){
-                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
-                                   (*_blossom_data)[blossom].offset);
-                }
-              }
-            }
-          } else {
+            Arc r = _graph.oppositeArc(e);
 
             typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              (*_node_data)[vi].heap.erase(it->second);
-              (*_node_data)[vi].heap_index.erase(it);
-              if ((*_node_data)[vi].heap.empty()) {
-                _blossom_set->increase(v, std::numeric_limits<Value>::max());
-              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
-                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
-              }
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_blossom_set->classPrio(vb) ==
-                    std::numeric_limits<Value>::max()) {
-                  _delta2->erase(vb);
-                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    void oddToMatched(int blossom) {
-      (*_blossom_data)[blossom].offset -= _delta_sum;
-
-      if (_blossom_set->classPrio(blossom) !=
-          std::numeric_limits<Value>::max()) {
-        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                      (*_blossom_data)[blossom].offset);
-      }
-
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-      }
-    }
-
-    void oddToEven(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-        (*_blossom_data)[blossom].pot -=
-          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
-      }
-
-      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
-           n != INVALID; ++n) {
-        int ni = (*_node_index)[n];
-
-        _blossom_set->increase(n, std::numeric_limits<Value>::max());
-
-        (*_node_data)[ni].heap.clear();
-        (*_node_data)[ni].heap_index.clear();
-        (*_node_data)[ni].pot +=
-          2 * _delta_sum - (*_blossom_data)[blossom].offset;
-
-        _delta1->push(n, (*_node_data)[ni].pot);
-
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.source(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
-              _delta3->push(e, rw / 2);
-            }
-          } else {
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              if ((*_node_data)[vi].heap[it->second] > rw) {
-                (*_node_data)[vi].heap.replace(it->second, e);
-                (*_node_data)[vi].heap.decrease(e, rw);
-                it->second = e;
+              (*_node_data)[ni].heap_index.find(vt);
+
+            if (it != (*_node_data)[ni].heap_index.end()) {
+              if ((*_node_data)[ni].heap[it->second] > rw) {
+                (*_node_data)[ni].heap.replace(it->second, r);
+                (*_node_data)[ni].heap.decrease(r, rw);
+                it->second = r;
               }
             } else {
-              (*_node_data)[vi].heap.push(e, rw);
-              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
-            }
-
-            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
-              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_delta2->state(vb) != _delta2->IN_HEAP) {
-                  _delta2->push(vb, _blossom_set->classPrio(vb) -
-                               (*_blossom_data)[vb].offset);
-                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
+              (*_node_data)[ni].heap.push(r, rw);
+              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+            }
+
+            if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+              _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+              if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                             (*_blossom_data)[blossom].offset);
+              } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)-
+                         (*_blossom_data)[blossom].offset){
+                _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                 (*_blossom_data)[blossom].offset);
               }
             }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
           }
         }
       }
-      (*_blossom_data)[blossom].offset = 0;
     }
 
@@ -1208,7 +1314,9 @@
       destroyTree(tree);
 
+      (*_blossom_data)[blossom].status = UNMATCHED;
       (*_blossom_data)[blossom].base = node;
-      (*_blossom_data)[blossom].next = INVALID;
-    }
+      matchedToUnmatched(blossom);
+    }
+
 
     void augmentOnEdge(const Edge& edge) {
@@ -1217,29 +1325,24 @@
       int right = _blossom_set->find(_graph.v(edge));
 
-      int left_tree = _tree_set->find(left);
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
+      if ((*_blossom_data)[left].status == EVEN) {
+        int left_tree = _tree_set->find(left);
+        alternatePath(left, left_tree);
+        destroyTree(left_tree);
+      } else {
+        (*_blossom_data)[left].status = MATCHED;
+        unmatchedToMatched(left);
+      }
+
+      if ((*_blossom_data)[right].status == EVEN) {
+        int right_tree = _tree_set->find(right);
+        alternatePath(right, right_tree);
+        destroyTree(right_tree);
+      } else {
+        (*_blossom_data)[right].status = MATCHED;
+        unmatchedToMatched(right);
+      }
 
       (*_blossom_data)[left].next = _graph.direct(edge, true);
       (*_blossom_data)[right].next = _graph.direct(edge, false);
-    }
-
-    void augmentOnArc(const Arc& arc) {
-
-      int left = _blossom_set->find(_graph.source(arc));
-      int right = _blossom_set->find(_graph.target(arc));
-
-      (*_blossom_data)[left].status = MATCHED;
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-
-      (*_blossom_data)[left].next = arc;
-      (*_blossom_data)[right].next = _graph.oppositeArc(arc);
     }
 
@@ -1446,5 +1549,5 @@
           (*_blossom_data)[sb].pred = pred;
           (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
+                           _graph.oppositeArc((*_blossom_data)[tb].next);
 
           pred = (*_blossom_data)[ub].next;
@@ -1546,5 +1649,5 @@
 
       for (int i = 0; i < int(blossoms.size()); ++i) {
-        if ((*_blossom_data)[blossoms[i]].next != INVALID) {
+        if ((*_blossom_data)[blossoms[i]].status == MATCHED) {
 
           Value offset = (*_blossom_data)[blossoms[i]].offset;
@@ -1584,14 +1687,8 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -1624,7 +1721,5 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
-
+      
       _delta1->clear();
       _delta2->clear();
@@ -1670,159 +1765,9 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      _fractional->run();
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta1_index)[n] = _delta1->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      _delta1->clear();
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        if (_fractional->matching(n) == INVALID) {
-          (*_blossom_data)[blossom].base = n;
-        }
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          _delta1->push(n, _fractional->nodeValue(n));
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            _delta1->push(v, _fractional->nodeValue(v));
-            v = _graph.target(_fractional->matching(v));
-          }
-
-          int surface =
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called
-    /// before using this function.
+    /// \pre \ref init() must be called before using this function.
     void start() {
       enum OpType {
@@ -1830,5 +1775,6 @@
       };
 
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d1 = !_delta1->empty() ?
           _delta1->prio() : std::numeric_limits<Value>::max();
@@ -1843,8 +1789,9 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; }
+        _delta_sum = d1; OpType ot = D1;
         if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
+
 
         switch (ot) {
@@ -1853,5 +1800,5 @@
             Node n = _delta1->top();
             unmatchNode(n);
-            --_unmatched;
+            --unmatched;
           }
           break;
@@ -1860,11 +1807,6 @@
             int blossom = _delta2->top();
             Node n = _blossom_set->classTop(blossom);
-            Arc a = (*_node_data)[(*_node_index)[n]].heap.top();
-            if ((*_blossom_data)[blossom].next == INVALID) {
-              augmentOnArc(a);
-              --_unmatched;
-            } else {
-              extendOnArc(a);
-            }
+            Arc e = (*_node_data)[(*_node_index)[n]].heap.top();
+            extendOnArc(e);
           }
           break;
@@ -1879,6 +1821,18 @@
               _delta3->pop();
             } else {
-              int left_tree = _tree_set->find(left_blossom);
-              int right_tree = _tree_set->find(right_blossom);
+              int left_tree;
+              if ((*_blossom_data)[left_blossom].status == EVEN) {
+                left_tree = _tree_set->find(left_blossom);
+              } else {
+                left_tree = -1;
+                ++unmatched;
+              }
+              int right_tree;
+              if ((*_blossom_data)[right_blossom].status == EVEN) {
+                right_tree = _tree_set->find(right_blossom);
+              } else {
+                right_tree = -1;
+                ++unmatched;
+              }
 
               if (left_tree == right_tree) {
@@ -1886,5 +1840,5 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -1904,9 +1858,9 @@
     /// \note mwm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwm.fractionalInit();
+    ///   mwm.init();
     ///   mwm.start();
     /// \endcode
     void run() {
-      fractionalInit();
+      init();
       start();
     }
@@ -1915,5 +1869,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -1934,5 +1888,5 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
@@ -1954,5 +1908,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -1965,5 +1919,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -1983,5 +1937,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -2003,6 +1957,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -2059,7 +2013,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedMatching class and execute it.
     class BlossomIt {
@@ -2070,6 +2024,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
-      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
+      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 
+      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 
       /// called before initializing this iterator.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
@@ -2124,6 +2078,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted perfect matching problem is to find a subset of
-  /// the edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted perfect matching problem is to find a subset of 
+  /// the edges in an undirected graph with maximum overall weight for which 
   /// each node has exactly one incident edge.
   /// It can be formulated with the following linear program.
@@ -2148,14 +2102,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -2268,9 +2222,4 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
-    FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -2334,4 +2283,7 @@
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -3006,14 +2958,8 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedPerfectMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -3043,6 +2989,4 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
 
       _delta2->clear();
@@ -3087,153 +3031,9 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      if (!_fractional->run()) {
-        _unmatched = -1;
-        return;
-      }
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            v = _graph.target(_fractional->matching(v));
-          }
-
-          int surface =
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called before
-    /// using this function.
+    /// \pre \ref init() must be called before using this function.
     bool start() {
       enum OpType {
@@ -3241,7 +3041,6 @@
       };
 
-      if (_unmatched == -1) return false;
-
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d2 = !_delta2->empty() ?
           _delta2->prio() : std::numeric_limits<Value>::max();
@@ -3253,6 +3052,6 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        _delta_sum = d2; OpType ot = D2;
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
 
@@ -3287,5 +3086,5 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -3306,9 +3105,9 @@
     /// \note mwpm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwpm.fractionalInit();
+    ///   mwpm.init();
     ///   mwpm.start();
     /// \endcode
     bool run() {
-      fractionalInit();
+      init();
       return start();
     }
@@ -3317,5 +3116,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// perfect matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -3336,10 +3135,10 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -3352,5 +3151,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -3370,5 +3169,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -3389,6 +3188,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -3445,7 +3244,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedPerfectMatching class and execute it.
     class BlossomIt {
@@ -3456,6 +3255,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
-      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
+      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 
+      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 
       /// must be called before initializing this iterator.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
@@ -3503,3 +3302,3 @@
 } //END OF NAMESPACE LEMON
 
-#endif //LEMON_MATCHING_H
+#endif //LEMON_MAX_MATCHING_H
Index: lemon/math.h
===================================================================
--- lemon/math.h	(revision 1222)
+++ lemon/math.h	(revision 558)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -57,5 +57,5 @@
 
   ///Check whether the parameter is NaN or not
-
+  
   ///This function checks whether the parameter is NaN or not.
   ///Is should be equivalent with std::isnan(), but it is not
@@ -66,12 +66,7 @@
     }
 
-  ///Round a value to its closest integer
-  inline double round(double r) {
-    return (r > 0.0) ? floor(r + 0.5) : ceil(r - 0.5);
-  }
-
   /// @}
 
 } //namespace lemon
 
-#endif //LEMON_MATH_H
+#endif //LEMON_TOLERANCE_H
Index: lemon/max_cardinality_search.h
===================================================================
--- lemon/max_cardinality_search.h	(revision 1129)
+++ 	(revision )
@@ -1,793 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_MAX_CARDINALITY_SEARCH_H
-#define LEMON_MAX_CARDINALITY_SEARCH_H
-
-
-/// \ingroup search
-/// \file 
-/// \brief Maximum cardinality search in undirected digraphs.
-
-#include <lemon/bin_heap.h>
-#include <lemon/bucket_heap.h>
-
-#include <lemon/error.h>
-#include <lemon/maps.h>
-
-#include <functional>
-
-namespace lemon {
-
-  /// \brief Default traits class of MaxCardinalitySearch class.
-  ///
-  /// Default traits class of MaxCardinalitySearch class.
-  /// \param Digraph Digraph type.
-  /// \param CapacityMap Type of capacity map.
-  template <typename GR, typename CAP>
-  struct MaxCardinalitySearchDefaultTraits {
-    /// The digraph type the algorithm runs on. 
-    typedef GR Digraph;
-
-    template <typename CM>
-    struct CapMapSelector {
-
-      typedef CM CapacityMap;
-
-      static CapacityMap *createCapacityMap(const Digraph& g) {
-	return new CapacityMap(g);
-      }
-    };
-
-    template <typename CM>
-    struct CapMapSelector<ConstMap<CM, Const<int, 1> > > {
-
-      typedef ConstMap<CM, Const<int, 1> > CapacityMap;
-
-      static CapacityMap *createCapacityMap(const Digraph&) {
-	return new CapacityMap;
-      }
-    };
-
-    /// \brief The type of the map that stores the arc capacities.
-    ///
-    /// The type of the map that stores the arc capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef typename CapMapSelector<CAP>::CapacityMap CapacityMap;
-
-    /// \brief The type of the capacity of the arcs.
-    typedef typename CapacityMap::Value Value;
-
-    /// \brief Instantiates a CapacityMap.
-    ///
-    /// This function instantiates a \ref CapacityMap.
-    /// \param digraph is the digraph, to which we would like to define
-    /// the CapacityMap.
-    static CapacityMap *createCapacityMap(const Digraph& digraph) {
-      return CapMapSelector<CapacityMap>::createCapacityMap(digraph);
-    }
-
-    /// \brief The cross reference type used by heap.
-    ///
-    /// The cross reference type used by heap.
-    /// Usually it is \c Digraph::NodeMap<int>.
-    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
-
-    /// \brief Instantiates a HeapCrossRef.
-    ///
-    /// This function instantiates a \ref HeapCrossRef. 
-    /// \param digraph is the digraph, to which we would like to define the 
-    /// HeapCrossRef.
-    static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-      return new HeapCrossRef(digraph);
-    }
-    
-    template <typename CapacityMap>
-    struct HeapSelector {
-      template <typename Value, typename Ref>
-      struct Selector { 
-        typedef BinHeap<Value, Ref, std::greater<Value> > Heap;
-      };
-    };
-
-    template <typename CapacityKey>
-    struct HeapSelector<ConstMap<CapacityKey, Const<int, 1> > > {
-      template <typename Value, typename Ref>
-      struct Selector {
-        typedef BucketHeap<Ref, false > Heap;
-      };
-    };
-
-    /// \brief The heap type used by MaxCardinalitySearch algorithm.
-    ///
-    /// The heap type used by MaxCardinalitySearch algorithm. It should
-    /// maximalize the priorities. The default heap type is
-    /// the \ref BinHeap, but it is specialized when the
-    /// CapacityMap is ConstMap<Digraph::Node, Const<int, 1> >
-    /// to BucketHeap.
-    ///
-    /// \sa MaxCardinalitySearch
-    typedef typename HeapSelector<CapacityMap>
-    ::template Selector<Value, HeapCrossRef>
-    ::Heap Heap;
-
-    /// \brief Instantiates a Heap.
-    ///
-    /// This function instantiates a \ref Heap. 
-    /// \param crossref The cross reference of the heap.
-    static Heap *createHeap(HeapCrossRef& crossref) {
-      return new Heap(crossref);
-    }
-
-    /// \brief The type of the map that stores whether a node is processed.
-    ///
-    /// The type of the map that stores whether a node is processed.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    /// By default it is a NullMap.
-    typedef NullMap<typename Digraph::Node, bool> ProcessedMap;
-
-    /// \brief Instantiates a ProcessedMap.
-    ///
-    /// This function instantiates a \ref ProcessedMap. 
-    /// \param digraph is the digraph, to which
-    /// we would like to define the \ref ProcessedMap
-#ifdef DOXYGEN
-    static ProcessedMap *createProcessedMap(const Digraph &digraph)
-#else
-    static ProcessedMap *createProcessedMap(const Digraph &)
-#endif
-    {
-      return new ProcessedMap();
-    }
-
-    /// \brief The type of the map that stores the cardinalities of the nodes.
-    /// 
-    /// The type of the map that stores the cardinalities of the nodes.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename Digraph::template NodeMap<Value> CardinalityMap;
-
-    /// \brief Instantiates a CardinalityMap.
-    ///
-    /// This function instantiates a \ref CardinalityMap. 
-    /// \param digraph is the digraph, to which we would like to define the \ref 
-    /// CardinalityMap
-    static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
-      return new CardinalityMap(digraph);
-    }
-
-
-  };
-  
-  /// \ingroup search
-  ///
-  /// \brief Maximum Cardinality Search algorithm class.
-  ///
-  /// This class provides an efficient implementation of Maximum Cardinality 
-  /// Search algorithm. The maximum cardinality search first chooses any 
-  /// node of the digraph. Then every time it chooses one unprocessed node
-  /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
-  /// which were previusly processed.
-  /// If there is a cut in the digraph the algorithm should choose
-  /// again any unprocessed node of the digraph.
-
-  /// The arc capacities are passed to the algorithm using a
-  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
-  /// kind of capacity.
-  ///
-  /// The type of the capacity is determined by the \ref 
-  /// concepts::ReadMap::Value "Value" of the capacity map.
-  ///
-  /// It is also possible to change the underlying priority heap.
-  ///
-  ///
-  /// \param GR The digraph type the algorithm runs on. The value of
-  /// Digraph is not used directly by the search algorithm, it 
-  /// is only passed to \ref MaxCardinalitySearchDefaultTraits.
-  /// \param CAP This read-only ArcMap determines the capacities of 
-  /// the arcs. It is read once for each arc, so the map may involve in
-  /// relatively time consuming process to compute the arc capacity if
-  /// it is necessary. The default map type is \ref
-  /// ConstMap "ConstMap<concepts::Digraph::Arc, Const<int,1> >". The value
-  /// of CapacityMap is not used directly by search algorithm, it is only 
-  /// passed to \ref MaxCardinalitySearchDefaultTraits.  
-  /// \param TR Traits class to set various data types used by the 
-  /// algorithm.  The default traits class is 
-  /// \ref MaxCardinalitySearchDefaultTraits 
-  /// "MaxCardinalitySearchDefaultTraits<GR, CAP>".  
-  /// See \ref MaxCardinalitySearchDefaultTraits 
-  /// for the documentation of a MaxCardinalitySearch traits class.
-
-#ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TR>
-#else
-  template <typename GR, typename CAP = 
-	    ConstMap<typename GR::Arc, Const<int,1> >,
-	    typename TR = 
-            MaxCardinalitySearchDefaultTraits<GR, CAP> >
-#endif
-  class MaxCardinalitySearch {
-  public:
-
-    typedef TR Traits;
-    ///The type of the underlying digraph.
-    typedef typename Traits::Digraph Digraph;
-    
-    ///The type of the capacity of the arcs.
-    typedef typename Traits::CapacityMap::Value Value;
-    ///The type of the map that stores the arc capacities.
-    typedef typename Traits::CapacityMap CapacityMap;
-    ///The type of the map indicating if a node is processed.
-    typedef typename Traits::ProcessedMap ProcessedMap;
-    ///The type of the map that stores the cardinalities of the nodes.
-    typedef typename Traits::CardinalityMap CardinalityMap;
-    ///The cross reference type used for the current heap.
-    typedef typename Traits::HeapCrossRef HeapCrossRef;
-    ///The heap type used by the algorithm. It maximizes the priorities.
-    typedef typename Traits::Heap Heap;
-  private:
-    // Pointer to the underlying digraph.
-    const Digraph *_graph;
-    // Pointer to the capacity map
-    const CapacityMap *_capacity;
-    // Indicates if \ref _capacity is locally allocated (\c true) or not.
-    bool local_capacity;
-    // Pointer to the map of cardinality.
-    CardinalityMap *_cardinality;
-    // Indicates if \ref _cardinality is locally allocated (\c true) or not.
-    bool local_cardinality;
-    // Pointer to the map of processed status of the nodes.
-    ProcessedMap *_processed;
-    // Indicates if \ref _processed is locally allocated (\c true) or not.
-    bool local_processed;
-    // Pointer to the heap cross references.
-    HeapCrossRef *_heap_cross_ref;
-    // Indicates if \ref _heap_cross_ref is locally allocated (\c true) or not.
-    bool local_heap_cross_ref;
-    // Pointer to the heap.
-    Heap *_heap;
-    // Indicates if \ref _heap is locally allocated (\c true) or not.
-    bool local_heap;
-
-  public :
-
-    typedef MaxCardinalitySearch Create;
- 
-    ///\name Named template parameters
-
-    ///@{
-
-    template <class T>
-    struct DefCapacityMapTraits : public Traits {
-      typedef T CapacityMap;
-      static CapacityMap *createCapacityMap(const Digraph &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
-    /// CapacityMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting CapacityMap type
-    /// for the algorithm.
-    template <class T>
-    struct SetCapacityMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefCapacityMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefCapacityMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct DefCardinalityMapTraits : public Traits {
-      typedef T CardinalityMap;
-      static CardinalityMap *createCardinalityMap(const Digraph &) 
-      {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
-    /// CardinalityMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting CardinalityMap 
-    /// type for the algorithm.
-    template <class T>
-    struct SetCardinalityMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefCardinalityMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefCardinalityMapTraits<T> > Create;
-    };
-    
-    template <class T>
-    struct DefProcessedMapTraits : public Traits {
-      typedef T ProcessedMap;
-      static ProcessedMap *createProcessedMap(const Digraph &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
-    /// ProcessedMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting ProcessedMap type
-    /// for the algorithm.
-    template <class T>
-    struct SetProcessedMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefProcessedMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefProcessedMapTraits<T> > Create;
-    };
-    
-    template <class H, class CR>
-    struct DefHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
-     	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-      static Heap *createHeap(HeapCrossRef &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting heap 
-    /// and cross reference type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross 
-    /// reference type for the algorithm.
-    template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct SetHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefHeapTraits<H, CR> > { 
-      typedef MaxCardinalitySearch< Digraph, CapacityMap, 
-                                    DefHeapTraits<H, CR> > Create;
-    };
-
-    template <class H, class CR>
-    struct DefStandardHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-	return new HeapCrossRef(digraph);
-      }
-      static Heap *createHeap(HeapCrossRef &crossref) {
-	return new Heap(crossref);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting heap and 
-    /// cross reference type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross 
-    /// reference type. It can allocate the heap and the cross reference 
-    /// object if the cross reference's constructor waits for the digraph as 
-    /// parameter and the heap's constructor waits for the cross reference.
-    template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct SetStandardHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefStandardHeapTraits<H, CR> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefStandardHeapTraits<H, CR> > 
-      Create;
-    };
-    
-    ///@}
-
-
-  protected:
-
-    MaxCardinalitySearch() {}
-
-  public:      
-    
-    /// \brief Constructor.
-    ///
-    ///\param digraph the digraph the algorithm will run on.
-    ///\param capacity the capacity map used by the algorithm.
-    MaxCardinalitySearch(const Digraph& digraph,
-			 const CapacityMap& capacity) :
-      _graph(&digraph),
-      _capacity(&capacity), local_capacity(false),
-      _cardinality(0), local_cardinality(false),
-      _processed(0), local_processed(false),
-      _heap_cross_ref(0), local_heap_cross_ref(false),
-      _heap(0), local_heap(false)
-    { }
-
-    /// \brief Constructor.
-    ///
-    ///\param digraph the digraph the algorithm will run on.
-    ///
-    ///A constant 1 capacity map will be allocated.
-    MaxCardinalitySearch(const Digraph& digraph) :
-      _graph(&digraph),
-      _capacity(0), local_capacity(false),
-      _cardinality(0), local_cardinality(false),
-      _processed(0), local_processed(false),
-      _heap_cross_ref(0), local_heap_cross_ref(false),
-      _heap(0), local_heap(false)
-    { }
-
-    /// \brief Destructor.
-    ~MaxCardinalitySearch() {
-      if(local_capacity) delete _capacity;
-      if(local_cardinality) delete _cardinality;
-      if(local_processed) delete _processed;
-      if(local_heap_cross_ref) delete _heap_cross_ref;
-      if(local_heap) delete _heap;
-    }
-
-    /// \brief Sets the capacity map.
-    ///
-    /// Sets the capacity map.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &capacityMap(const CapacityMap &m) {
-      if (local_capacity) {
-	delete _capacity;
-	local_capacity=false;
-      }
-      _capacity=&m;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the capacity map.
-    ///
-    /// Returns a const reference to the capacity map used by
-    /// the algorithm.
-    const CapacityMap &capacityMap() const {
-      return *_capacity;
-    }
-
-    /// \brief Sets the map storing the cardinalities calculated by the 
-    /// algorithm.
-    ///
-    /// Sets the map storing the cardinalities calculated by the algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) {
-      if(local_cardinality) {
-	delete _cardinality;
-	local_cardinality=false;
-      }
-      _cardinality = &m;
-      return *this;
-    }
-
-    /// \brief Sets the map storing the processed nodes.
-    ///
-    /// Sets the map storing the processed nodes.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &processedMap(ProcessedMap &m) 
-    {
-      if(local_processed) {
-	delete _processed;
-	local_processed=false;
-      }
-      _processed = &m;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the cardinality map.
-    ///
-    /// Returns a const reference to the cardinality map used by
-    /// the algorithm.
-    const ProcessedMap &processedMap() const {
-      return *_processed;
-    }
-
-    /// \brief Sets the heap and the cross reference used by algorithm.
-    ///
-    /// Sets the heap and the cross reference used by algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) {
-      if(local_heap_cross_ref) {
-	delete _heap_cross_ref;
-	local_heap_cross_ref = false;
-      }
-      _heap_cross_ref = &cr;
-      if(local_heap) {
-	delete _heap;
-	local_heap = false;
-      }
-      _heap = &hp;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the heap.
-    ///
-    /// Returns a const reference to the heap used by
-    /// the algorithm.
-    const Heap &heap() const {
-      return *_heap;
-    }
-
-    /// \brief Returns a const reference to the cross reference.
-    ///
-    /// Returns a const reference to the cross reference
-    /// of the heap.
-    const HeapCrossRef &heapCrossRef() const {
-      return *_heap_cross_ref;
-    }
-
-  private:
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::InArcIt InArcIt;
-
-    void create_maps() {
-      if(!_capacity) {
-	local_capacity = true;
-	_capacity = Traits::createCapacityMap(*_graph);
-      }
-      if(!_cardinality) {
-	local_cardinality = true;
-	_cardinality = Traits::createCardinalityMap(*_graph);
-      }
-      if(!_processed) {
-	local_processed = true;
-	_processed = Traits::createProcessedMap(*_graph);
-      }
-      if (!_heap_cross_ref) {
-	local_heap_cross_ref = true;
-	_heap_cross_ref = Traits::createHeapCrossRef(*_graph);
-      }
-      if (!_heap) {
-	local_heap = true;
-	_heap = Traits::createHeap(*_heap_cross_ref);
-      }
-    }
-    
-    void finalizeNodeData(Node node, Value capacity) {
-      _processed->set(node, true);
-      _cardinality->set(node, capacity);
-    }
-
-  public:
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \ref run().
-    /// \n
-    /// If you need more control on the execution,
-    /// first you must call \ref init(), then you can add several source nodes
-    /// with \ref addSource().
-    /// Finally \ref start() will perform the computation.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures, and clears the heap.
-    void init() {
-      create_maps();
-      _heap->clear();
-      for (NodeIt it(*_graph) ; it != INVALID ; ++it) {
-	_processed->set(it, false);
-	_heap_cross_ref->set(it, Heap::PRE_HEAP);
-      }
-    }
-    
-    /// \brief Adds a new source node.
-    /// 
-    /// Adds a new source node to the priority heap.
-    ///
-    /// It checks if the node has not yet been added to the heap.
-    void addSource(Node source, Value capacity = 0) {
-      if(_heap->state(source) == Heap::PRE_HEAP) {
-	_heap->push(source, capacity);
-      } 
-    }
-    
-    /// \brief Processes the next node in the priority heap
-    ///
-    /// Processes the next node in the priority heap.
-    ///
-    /// \return The processed node.
-    ///
-    /// \warning The priority heap must not be empty!
-    Node processNextNode() {
-      Node node = _heap->top(); 
-      finalizeNodeData(node, _heap->prio());
-      _heap->pop();
-      
-      for (InArcIt it(*_graph, node); it != INVALID; ++it) {
-	Node source = _graph->source(it);
-	switch (_heap->state(source)) {
-	case Heap::PRE_HEAP:
-	  _heap->push(source, (*_capacity)[it]);
-	  break;
-	case Heap::IN_HEAP:
-	  _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]);
-	  break;
-	case Heap::POST_HEAP:
-	  break;
-	}
-      }
-      return node;
-    }
-
-    /// \brief Next node to be processed.
-    ///
-    /// Next node to be processed.
-    ///
-    /// \return The next node to be processed or INVALID if the 
-    /// priority heap is empty.
-    Node nextNode() { 
-      return !_heap->empty() ? _heap->top() : INVALID;
-    }
- 
-    /// \brief Returns \c false if there are nodes
-    /// to be processed in the priority heap
-    ///
-    /// Returns \c false if there are nodes
-    /// to be processed in the priority heap
-    bool emptyQueue() { return _heap->empty(); }
-    /// \brief Returns the number of the nodes to be processed 
-    /// in the priority heap
-    ///
-    /// Returns the number of the nodes to be processed in the priority heap
-    int emptySize() { return _heap->size(); }
-    
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    ///\pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// This method runs the Maximum Cardinality Search algorithm from the 
-    /// source node(s).
-    void start() {
-      while ( !_heap->empty() ) processNextNode();
-    }
-    
-    /// \brief Executes the algorithm until \c dest is reached.
-    ///
-    /// Executes the algorithm until \c dest is reached.
-    ///
-    /// \pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from the source 
-    /// nodes.
-    void start(Node dest) {
-      while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
-      if ( !_heap->empty() ) finalizeNodeData(_heap->top(), _heap->prio());
-    }
-    
-    /// \brief Executes the algorithm until a condition is met.
-    ///
-    /// Executes the algorithm until a condition is met.
-    ///
-    /// \pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// \param nm must be a bool (or convertible) node map. The algorithm
-    /// will stop when it reaches a node \c v with <tt>nm[v]==true</tt>.
-    template <typename NodeBoolMap>
-    void start(const NodeBoolMap &nm) {
-      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
-      if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
-    }
-    
-    /// \brief Runs the maximum cardinality search algorithm from node \c s.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from a root 
-    /// node \c s.
-    ///
-    ///\note d.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  d.init();
-    ///  d.addSource(s);
-    ///  d.start();
-    ///\endcode
-    void run(Node s) {
-      init();
-      addSource(s);
-      start();
-    }
-
-    /// \brief Runs the maximum cardinality search algorithm for the 
-    /// whole digraph.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from all 
-    /// unprocessed node of the digraph.
-    ///
-    ///\note d.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  d.init();
-    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
-    ///    if (!d.reached(it)) {
-    ///      d.addSource(s);
-    ///      d.start();
-    ///    }
-    ///  }
-    ///\endcode
-    void run() {
-      init();
-      for (NodeIt it(*_graph); it != INVALID; ++it) {
-        if (!reached(it)) {
-          addSource(it);
-          start();
-        }
-      }
-    }
-    
-    ///@}
-
-    /// \name Query Functions
-    /// The results of the maximum cardinality search algorithm can be 
-    /// obtained using these functions.
-    /// \n
-    /// Before the use of these functions, either run() or start() must be 
-    /// called.
-    
-    ///@{
-
-    /// \brief The cardinality of a node.
-    ///
-    /// Returns the cardinality of a node.
-    /// \pre \ref run() must be called before using this function.
-    /// \warning If node \c v in unreachable from the root the return value
-    /// of this funcion is undefined.
-    Value cardinality(Node node) const { return (*_cardinality)[node]; }
-
-    /// \brief The current cardinality of a node.
-    ///
-    /// Returns the current cardinality of a node.
-    /// \pre the given node should be reached but not processed
-    Value currentCardinality(Node node) const { return (*_heap)[node]; }
-
-    /// \brief Returns a reference to the NodeMap of cardinalities.
-    ///
-    /// Returns a reference to the NodeMap of cardinalities. \pre \ref run() 
-    /// must be called before using this function.
-    const CardinalityMap &cardinalityMap() const { return *_cardinality;}
- 
-    /// \brief Checks if a node is reachable from the root.
-    ///
-    /// Returns \c true if \c v is reachable from the root.
-    /// \warning The source nodes are initated as unreached.
-    /// \pre \ref run() must be called before using this function.
-    bool reached(Node v) { return (*_heap_cross_ref)[v] != Heap::PRE_HEAP; }
-
-    /// \brief Checks if a node is processed.
-    ///
-    /// Returns \c true if \c v is processed, i.e. the shortest
-    /// path to \c v has already found.
-    /// \pre \ref run() must be called before using this function.
-    bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
-    
-    ///@}
-  };
-
-}
-
-#endif
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 1254)
+++ lemon/min_cost_arborescence.h	(revision 672)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -102,5 +102,5 @@
   /// the minimum cost subgraph that is the union of arborescences with the
   /// given sources and spans all the nodes which are reachable from the
-  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+m).
+  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
   ///
   /// The algorithm also provides an optimal dual solution, therefore
@@ -113,9 +113,8 @@
   /// it is necessary. The default map type is \ref
   /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref MinCostArborescenceDefaultTraits
+  /// \param TR Traits class to set various data types used
+  /// by the algorithm. The default traits class is
+  /// \ref MinCostArborescenceDefaultTraits
   /// "MinCostArborescenceDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
 #ifndef DOXYGEN
   template <typename GR,
@@ -124,11 +123,11 @@
               MinCostArborescenceDefaultTraits<GR, CM> >
 #else
-  template <typename GR, typename CM, typename TR>
+  template <typename GR, typename CM, typedef TR>
 #endif
   class MinCostArborescence {
   public:
 
-    /// \brief The \ref lemon::MinCostArborescenceDefaultTraits "traits class"
-    /// of the algorithm.
+    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" 
+    /// of the algorithm. 
     typedef TR Traits;
     /// The type of the underlying digraph.
@@ -437,5 +436,5 @@
     /// \ref named-templ-param "Named parameter" for setting
     /// \c PredMap type.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept, 
     /// and its value type must be the \c Arc type of the digraph.
     template <class T>
@@ -490,6 +489,6 @@
     /// The simplest way to execute the algorithm is to use
     /// one of the member functions called \c run(...). \n
-    /// If you need better control on the execution,
-    /// you have to call \ref init() first, then you can add several
+    /// If you need more control on the execution,
+    /// first you must call \ref init(), then you can add several
     /// source nodes with \ref addSource().
     /// Finally \ref start() will perform the arborescence
Index: lemon/nagamochi_ibaraki.h
===================================================================
--- lemon/nagamochi_ibaraki.h	(revision 1130)
+++ 	(revision )
@@ -1,702 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_NAGAMOCHI_IBARAKI_H
-#define LEMON_NAGAMOCHI_IBARAKI_H
-
-
-/// \ingroup min_cut
-/// \file
-/// \brief Implementation of the Nagamochi-Ibaraki algorithm.
-
-#include <lemon/core.h>
-#include <lemon/bin_heap.h>
-#include <lemon/bucket_heap.h>
-#include <lemon/maps.h>
-#include <lemon/radix_sort.h>
-#include <lemon/unionfind.h>
-
-#include <cassert>
-
-namespace lemon {
-
-  /// \brief Default traits class for NagamochiIbaraki class.
-  ///
-  /// Default traits class for NagamochiIbaraki class.
-  /// \param GR The undirected graph type.
-  /// \param CM Type of capacity map.
-  template <typename GR, typename CM>
-  struct NagamochiIbarakiDefaultTraits {
-    /// The type of the capacity map.
-    typedef typename CM::Value Value;
-
-    /// The undirected graph type the algorithm runs on.
-    typedef GR Graph;
-
-    /// \brief The type of the map that stores the edge capacities.
-    ///
-    /// The type of the map that stores the edge capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CM CapacityMap;
-
-    /// \brief Instantiates a CapacityMap.
-    ///
-    /// This function instantiates a \ref CapacityMap.
-#ifdef DOXYGEN
-    static CapacityMap *createCapacityMap(const Graph& graph)
-#else
-    static CapacityMap *createCapacityMap(const Graph&)
-#endif
-    {
-        LEMON_ASSERT(false, "CapacityMap is not initialized");
-        return 0; // ignore warnings
-    }
-
-    /// \brief The cross reference type used by heap.
-    ///
-    /// The cross reference type used by heap.
-    /// Usually \c Graph::NodeMap<int>.
-    typedef typename Graph::template NodeMap<int> HeapCrossRef;
-
-    /// \brief Instantiates a HeapCrossRef.
-    ///
-    /// This function instantiates a \ref HeapCrossRef.
-    /// \param g is the graph, to which we would like to define the
-    /// \ref HeapCrossRef.
-    static HeapCrossRef *createHeapCrossRef(const Graph& g) {
-      return new HeapCrossRef(g);
-    }
-
-    /// \brief The heap type used by NagamochiIbaraki algorithm.
-    ///
-    /// The heap type used by NagamochiIbaraki algorithm. It has to
-    /// maximize the priorities.
-    ///
-    /// \sa BinHeap
-    /// \sa NagamochiIbaraki
-    typedef BinHeap<Value, HeapCrossRef, std::greater<Value> > Heap;
-
-    /// \brief Instantiates a Heap.
-    ///
-    /// This function instantiates a \ref Heap.
-    /// \param r is the cross reference of the heap.
-    static Heap *createHeap(HeapCrossRef& r) {
-      return new Heap(r);
-    }
-  };
-
-  /// \ingroup min_cut
-  ///
-  /// \brief Calculates the minimum cut in an undirected graph.
-  ///
-  /// Calculates the minimum cut in an undirected graph with the
-  /// Nagamochi-Ibaraki algorithm. The algorithm separates the graph's
-  /// nodes into two partitions with the minimum sum of edge capacities
-  /// between the two partitions. The algorithm can be used to test
-  /// the network reliability, especially to test how many links have
-  /// to be destroyed in the network to split it to at least two
-  /// distinict subnetworks.
-  ///
-  /// The complexity of the algorithm is \f$ O(nm\log(n)) \f$ but with
-  /// \ref FibHeap "Fibonacci heap" it can be decreased to
-  /// \f$ O(nm+n^2\log(n)) \f$.  When the edges have unit capacities,
-  /// \c BucketHeap can be used which yields \f$ O(nm) \f$ time
-  /// complexity.
-  ///
-  /// \warning The value type of the capacity map should be able to
-  /// hold any cut value of the graph, otherwise the result can
-  /// overflow.
-  /// \note This capacity is supposed to be integer type.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template <typename GR,
-            typename CM = typename GR::template EdgeMap<int>,
-            typename TR = NagamochiIbarakiDefaultTraits<GR, CM> >
-#endif
-  class NagamochiIbaraki {
-  public:
-
-    typedef TR Traits;
-    /// The type of the underlying graph.
-    typedef typename Traits::Graph Graph;
-
-    /// The type of the capacity map.
-    typedef typename Traits::CapacityMap CapacityMap;
-    /// The value type of the capacity map.
-    typedef typename Traits::CapacityMap::Value Value;
-
-    /// The heap type used by the algorithm.
-    typedef typename Traits::Heap Heap;
-    /// The cross reference type used for the heap.
-    typedef typename Traits::HeapCrossRef HeapCrossRef;
-
-    ///\name Named template parameters
-
-    ///@{
-
-    struct SetUnitCapacityTraits : public Traits {
-      typedef ConstMap<typename Graph::Edge, Const<int, 1> > CapacityMap;
-      static CapacityMap *createCapacityMap(const Graph&) {
-        return new CapacityMap();
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// the capacity map to a constMap<Edge, int, 1>() instance
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// the capacity map to a constMap<Edge, int, 1>() instance
-    struct SetUnitCapacity
-      : public NagamochiIbaraki<Graph, CapacityMap,
-                                SetUnitCapacityTraits> {
-      typedef NagamochiIbaraki<Graph, CapacityMap,
-                               SetUnitCapacityTraits> Create;
-    };
-
-
-    template <class H, class CR>
-    struct SetHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(int num) {
-        LEMON_ASSERT(false, "HeapCrossRef is not initialized");
-        return 0; // ignore warnings
-      }
-      static Heap *createHeap(HeapCrossRef &) {
-        LEMON_ASSERT(false, "Heap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// heap and cross reference type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and
-    /// cross reference type. The heap has to maximize the priorities.
-    template <class H, class CR = RangeMap<int> >
-    struct SetHeap
-      : public NagamochiIbaraki<Graph, CapacityMap, SetHeapTraits<H, CR> > {
-      typedef NagamochiIbaraki< Graph, CapacityMap, SetHeapTraits<H, CR> >
-      Create;
-    };
-
-    template <class H, class CR>
-    struct SetStandardHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(int size) {
-        return new HeapCrossRef(size);
-      }
-      static Heap *createHeap(HeapCrossRef &crossref) {
-        return new Heap(crossref);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// heap and cross reference type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and
-    /// cross reference type with automatic allocation. They should
-    /// have standard constructor interfaces to be able to
-    /// automatically created by the algorithm (i.e. the graph should
-    /// be passed to the constructor of the cross reference and the
-    /// cross reference should be passed to the constructor of the
-    /// heap). However, external heap and cross reference objects
-    /// could also be passed to the algorithm using the \ref heap()
-    /// function before calling \ref run() or \ref init(). The heap
-    /// has to maximize the priorities.
-    /// \sa SetHeap
-    template <class H, class CR = RangeMap<int> >
-    struct SetStandardHeap
-      : public NagamochiIbaraki<Graph, CapacityMap,
-                                SetStandardHeapTraits<H, CR> > {
-      typedef NagamochiIbaraki<Graph, CapacityMap,
-                               SetStandardHeapTraits<H, CR> > Create;
-    };
-
-    ///@}
-
-
-  private:
-
-    const Graph &_graph;
-    const CapacityMap *_capacity;
-    bool _local_capacity; // unit capacity
-
-    struct ArcData {
-      typename Graph::Node target;
-      int prev, next;
-    };
-    struct EdgeData {
-      Value capacity;
-      Value cut;
-    };
-
-    struct NodeData {
-      int first_arc;
-      typename Graph::Node prev, next;
-      int curr_arc;
-      typename Graph::Node last_rep;
-      Value sum;
-    };
-
-    typename Graph::template NodeMap<NodeData> *_nodes;
-    std::vector<ArcData> _arcs;
-    std::vector<EdgeData> _edges;
-
-    typename Graph::Node _first_node;
-    int _node_num;
-
-    Value _min_cut;
-
-    HeapCrossRef *_heap_cross_ref;
-    bool _local_heap_cross_ref;
-    Heap *_heap;
-    bool _local_heap;
-
-    typedef typename Graph::template NodeMap<typename Graph::Node> NodeList;
-    NodeList *_next_rep;
-
-    typedef typename Graph::template NodeMap<bool> MinCutMap;
-    MinCutMap *_cut_map;
-
-    void createStructures() {
-      if (!_nodes) {
-        _nodes = new (typename Graph::template NodeMap<NodeData>)(_graph);
-      }
-      if (!_capacity) {
-        _local_capacity = true;
-        _capacity = Traits::createCapacityMap(_graph);
-      }
-      if (!_heap_cross_ref) {
-        _local_heap_cross_ref = true;
-        _heap_cross_ref = Traits::createHeapCrossRef(_graph);
-      }
-      if (!_heap) {
-        _local_heap = true;
-        _heap = Traits::createHeap(*_heap_cross_ref);
-      }
-      if (!_next_rep) {
-        _next_rep = new NodeList(_graph);
-      }
-      if (!_cut_map) {
-        _cut_map = new MinCutMap(_graph);
-      }
-    }
-
-  protected:
-    //This is here to avoid a gcc-3.3 compilation error.
-    //It should never be called.
-    NagamochiIbaraki() {} 
-    
-  public:
-
-    typedef NagamochiIbaraki Create;
-
-
-    /// \brief Constructor.
-    ///
-    /// \param graph The graph the algorithm runs on.
-    /// \param capacity The capacity map used by the algorithm.
-    NagamochiIbaraki(const Graph& graph, const CapacityMap& capacity)
-      : _graph(graph), _capacity(&capacity), _local_capacity(false),
-        _nodes(0), _arcs(), _edges(), _min_cut(),
-        _heap_cross_ref(0), _local_heap_cross_ref(false),
-        _heap(0), _local_heap(false),
-        _next_rep(0), _cut_map(0) {}
-
-    /// \brief Constructor.
-    ///
-    /// This constructor can be used only when the Traits class
-    /// defines how can the local capacity map be instantiated.
-    /// If the SetUnitCapacity used the algorithm automatically
-    /// constructs the capacity map.
-    ///
-    ///\param graph The graph the algorithm runs on.
-    NagamochiIbaraki(const Graph& graph)
-      : _graph(graph), _capacity(0), _local_capacity(false),
-        _nodes(0), _arcs(), _edges(), _min_cut(),
-        _heap_cross_ref(0), _local_heap_cross_ref(false),
-        _heap(0), _local_heap(false),
-        _next_rep(0), _cut_map(0) {}
-
-    /// \brief Destructor.
-    ///
-    /// Destructor.
-    ~NagamochiIbaraki() {
-      if (_local_capacity) delete _capacity;
-      if (_nodes) delete _nodes;
-      if (_local_heap) delete _heap;
-      if (_local_heap_cross_ref) delete _heap_cross_ref;
-      if (_next_rep) delete _next_rep;
-      if (_cut_map) delete _cut_map;
-    }
-
-    /// \brief Sets the heap and the cross reference used by algorithm.
-    ///
-    /// Sets the heap and the cross reference used by algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated heap and cross reference, of course.
-    /// \return <tt> (*this) </tt>
-    NagamochiIbaraki &heap(Heap& hp, HeapCrossRef &cr)
-    {
-      if (_local_heap_cross_ref) {
-        delete _heap_cross_ref;
-        _local_heap_cross_ref = false;
-      }
-      _heap_cross_ref = &cr;
-      if (_local_heap) {
-        delete _heap;
-        _local_heap = false;
-      }
-      _heap = &hp;
-      return *this;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \c run().
-    /// \n
-    /// If you need more control on the execution,
-    /// first you must call \ref init() and then call the start()
-    /// or proper times the processNextPhase() member functions.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures.
-    void init() {
-      createStructures();
-
-      int edge_num = countEdges(_graph);
-      _edges.resize(edge_num);
-      _arcs.resize(2 * edge_num);
-
-      typename Graph::Node prev = INVALID;
-      _node_num = 0;
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        (*_cut_map)[n] = false;
-        (*_next_rep)[n] = INVALID;
-        (*_nodes)[n].last_rep = n;
-        (*_nodes)[n].first_arc = -1;
-        (*_nodes)[n].curr_arc = -1;
-        (*_nodes)[n].prev = prev;
-        if (prev != INVALID) {
-          (*_nodes)[prev].next = n;
-        }
-        (*_nodes)[n].next = INVALID;
-        (*_nodes)[n].sum = 0;
-        prev = n;
-        ++_node_num;
-      }
-
-      _first_node = typename Graph::NodeIt(_graph);
-
-      int index = 0;
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        for (typename Graph::OutArcIt a(_graph, n); a != INVALID; ++a) {
-          typename Graph::Node m = _graph.target(a);
-          
-          if (!(n < m)) continue;
-
-          (*_nodes)[n].sum += (*_capacity)[a];
-          (*_nodes)[m].sum += (*_capacity)[a];
-          
-          int c = (*_nodes)[m].curr_arc;
-          if (c != -1 && _arcs[c ^ 1].target == n) {
-            _edges[c >> 1].capacity += (*_capacity)[a];
-          } else {
-            _edges[index].capacity = (*_capacity)[a];
-            
-            _arcs[index << 1].prev = -1;
-            if ((*_nodes)[n].first_arc != -1) {
-              _arcs[(*_nodes)[n].first_arc].prev = (index << 1);
-            }
-            _arcs[index << 1].next = (*_nodes)[n].first_arc;
-            (*_nodes)[n].first_arc = (index << 1);
-            _arcs[index << 1].target = m;
-
-            (*_nodes)[m].curr_arc = (index << 1);
-            
-            _arcs[(index << 1) | 1].prev = -1;
-            if ((*_nodes)[m].first_arc != -1) {
-              _arcs[(*_nodes)[m].first_arc].prev = ((index << 1) | 1);
-            }
-            _arcs[(index << 1) | 1].next = (*_nodes)[m].first_arc;
-            (*_nodes)[m].first_arc = ((index << 1) | 1);
-            _arcs[(index << 1) | 1].target = n;
-            
-            ++index;
-          }
-        }
-      }
-
-      typename Graph::Node cut_node = INVALID;
-      _min_cut = std::numeric_limits<Value>::max();
-
-      for (typename Graph::Node n = _first_node; 
-           n != INVALID; n = (*_nodes)[n].next) {
-        if ((*_nodes)[n].sum < _min_cut) {
-          cut_node = n;
-          _min_cut = (*_nodes)[n].sum;
-        }
-      }
-      (*_cut_map)[cut_node] = true;
-      if (_min_cut == 0) {
-        _first_node = INVALID;
-      }
-    }
-
-  public:
-
-    /// \brief Processes the next phase
-    ///
-    /// Processes the next phase in the algorithm. It must be called
-    /// at most one less the number of the nodes in the graph.
-    ///
-    ///\return %True when the algorithm finished.
-    bool processNextPhase() {
-      if (_first_node == INVALID) return true;
-
-      _heap->clear();
-      for (typename Graph::Node n = _first_node; 
-           n != INVALID; n = (*_nodes)[n].next) {
-        (*_heap_cross_ref)[n] = Heap::PRE_HEAP;
-      }
-
-      std::vector<typename Graph::Node> order;
-      order.reserve(_node_num);
-      int sep = 0;
-
-      Value alpha = 0;
-      Value pmc = std::numeric_limits<Value>::max();
-
-      _heap->push(_first_node, static_cast<Value>(0));
-      while (!_heap->empty()) {
-        typename Graph::Node n = _heap->top();
-        Value v = _heap->prio();
-
-        _heap->pop();
-        for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) {
-          switch (_heap->state(_arcs[a].target)) {
-          case Heap::PRE_HEAP: 
-            {
-              Value nv = _edges[a >> 1].capacity;
-              _heap->push(_arcs[a].target, nv);
-              _edges[a >> 1].cut = nv;
-            } break;
-          case Heap::IN_HEAP:
-            {
-              Value nv = _edges[a >> 1].capacity + (*_heap)[_arcs[a].target];
-              _heap->decrease(_arcs[a].target, nv);
-              _edges[a >> 1].cut = nv;
-            } break;
-          case Heap::POST_HEAP:
-            break;
-          }
-        }
-
-        alpha += (*_nodes)[n].sum;
-        alpha -= 2 * v;
-
-        order.push_back(n);
-        if (!_heap->empty()) {
-          if (alpha < pmc) {
-            pmc = alpha;
-            sep = order.size();
-          }
-        }
-      }
-
-      if (static_cast<int>(order.size()) < _node_num) {
-        _first_node = INVALID;
-        for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-          (*_cut_map)[n] = false;
-        }
-        for (int i = 0; i < static_cast<int>(order.size()); ++i) {
-          typename Graph::Node n = order[i];
-          while (n != INVALID) {
-            (*_cut_map)[n] = true;
-            n = (*_next_rep)[n];
-          }
-        }
-        _min_cut = 0;
-        return true;
-      }
-
-      if (pmc < _min_cut) {
-        for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-          (*_cut_map)[n] = false;
-        }
-        for (int i = 0; i < sep; ++i) {
-          typename Graph::Node n = order[i];
-          while (n != INVALID) {
-            (*_cut_map)[n] = true;
-            n = (*_next_rep)[n];
-          }
-        }
-        _min_cut = pmc;
-      }
-
-      for (typename Graph::Node n = _first_node;
-           n != INVALID; n = (*_nodes)[n].next) {
-        bool merged = false;
-        for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) {
-          if (!(_edges[a >> 1].cut < pmc)) {
-            if (!merged) {
-              for (int b = (*_nodes)[n].first_arc; b != -1; b = _arcs[b].next) {
-                (*_nodes)[_arcs[b].target].curr_arc = b;          
-              }
-              merged = true;
-            }
-            typename Graph::Node m = _arcs[a].target;
-            int nb = 0;
-            for (int b = (*_nodes)[m].first_arc; b != -1; b = nb) {
-              nb = _arcs[b].next;
-              if ((b ^ a) == 1) continue;
-              typename Graph::Node o = _arcs[b].target;
-              int c = (*_nodes)[o].curr_arc; 
-              if (c != -1 && _arcs[c ^ 1].target == n) {
-                _edges[c >> 1].capacity += _edges[b >> 1].capacity;
-                (*_nodes)[n].sum += _edges[b >> 1].capacity;
-                if (_edges[b >> 1].cut < _edges[c >> 1].cut) {
-                  _edges[b >> 1].cut = _edges[c >> 1].cut;
-                }
-                if (_arcs[b ^ 1].prev != -1) {
-                  _arcs[_arcs[b ^ 1].prev].next = _arcs[b ^ 1].next;
-                } else {
-                  (*_nodes)[o].first_arc = _arcs[b ^ 1].next;
-                }
-                if (_arcs[b ^ 1].next != -1) {
-                  _arcs[_arcs[b ^ 1].next].prev = _arcs[b ^ 1].prev;
-                }
-              } else {
-                if (_arcs[a].next != -1) {
-                  _arcs[_arcs[a].next].prev = b;
-                }
-                _arcs[b].next = _arcs[a].next;
-                _arcs[b].prev = a;
-                _arcs[a].next = b;
-                _arcs[b ^ 1].target = n;
-
-                (*_nodes)[n].sum += _edges[b >> 1].capacity;
-                (*_nodes)[o].curr_arc = b;
-              }
-            }
-
-            if (_arcs[a].prev != -1) {
-              _arcs[_arcs[a].prev].next = _arcs[a].next;
-            } else {
-              (*_nodes)[n].first_arc = _arcs[a].next;
-            }            
-            if (_arcs[a].next != -1) {
-              _arcs[_arcs[a].next].prev = _arcs[a].prev;
-            }
-
-            (*_nodes)[n].sum -= _edges[a >> 1].capacity;
-            (*_next_rep)[(*_nodes)[n].last_rep] = m;
-            (*_nodes)[n].last_rep = (*_nodes)[m].last_rep;
-            
-            if ((*_nodes)[m].prev != INVALID) {
-              (*_nodes)[(*_nodes)[m].prev].next = (*_nodes)[m].next;
-            } else{
-              _first_node = (*_nodes)[m].next;
-            }
-            if ((*_nodes)[m].next != INVALID) {
-              (*_nodes)[(*_nodes)[m].next].prev = (*_nodes)[m].prev;
-            }
-            --_node_num;
-          }
-        }
-      }
-
-      if (_node_num == 1) {
-        _first_node = INVALID;
-        return true;
-      }
-
-      return false;
-    }
-
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    /// \pre init() must be called
-    void start() {
-      while (!processNextPhase()) {}
-    }
-
-
-    /// \brief Runs %NagamochiIbaraki algorithm.
-    ///
-    /// This method runs the %Min cut algorithm
-    ///
-    /// \note mc.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  mc.init();
-    ///  mc.start();
-    ///\endcode
-    void run() {
-      init();
-      start();
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    ///
-    /// The result of the %NagamochiIbaraki
-    /// algorithm can be obtained using these functions.\n
-    /// Before the use of these functions, either run() or start()
-    /// must be called.
-
-    ///@{
-
-    /// \brief Returns the min cut value.
-    ///
-    /// Returns the min cut value if the algorithm finished.
-    /// After the first processNextPhase() it is a value of a
-    /// valid cut in the graph.
-    Value minCutValue() const {
-      return _min_cut;
-    }
-
-    /// \brief Returns a min cut in a NodeMap.
-    ///
-    /// It sets the nodes of one of the two partitions to true and
-    /// the other partition to false.
-    /// \param cutMap A \ref concepts::WriteMap "writable" node map with
-    /// \c bool (or convertible) value type.
-    template <typename CutMap>
-    Value minCutMap(CutMap& cutMap) const {
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        cutMap.set(n, (*_cut_map)[n]);
-      }
-      return minCutValue();
-    }
-
-    ///@}
-
-  };
-}
-
-#endif
Index: lemon/nearest_neighbor_tsp.h
===================================================================
--- lemon/nearest_neighbor_tsp.h	(revision 1250)
+++ 	(revision )
@@ -1,238 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_NEAREST_NEIGHBOUR_TSP_H
-#define LEMON_NEAREST_NEIGHBOUR_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief Nearest neighbor algorithm for symmetric TSP
-
-#include <deque>
-#include <vector>
-#include <limits>
-#include <lemon/full_graph.h>
-#include <lemon/maps.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief Nearest neighbor algorithm for symmetric TSP.
-  ///
-  /// NearestNeighborTsp implements the nearest neighbor heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This is probably the simplest TSP heuristic.
-  /// It starts with a minimum cost edge and at each step, it connects the
-  /// nearest unvisited node to the current path.
-  /// Finally, it connects the two end points of the path to form a tour.
-  ///
-  /// This method runs in O(n<sup>2</sup>) time.
-  /// It quickly finds a relatively short tour for most TSP instances,
-  /// but it could also yield a really bad (or even the worst) solution
-  /// in special cases.
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class NearestNeighborTsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      Cost _sum;
-      std::vector<Node> _path;
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      NearestNeighborTsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm.
-      ///
-      /// This function runs the algorithm.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-        if (_gr.nodeNum() == 0) {
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-
-        std::deque<Node> path_dq;
-        Edge min_edge1 = INVALID,
-             min_edge2 = INVALID;
-
-        min_edge1 = mapMin(_gr, _cost);
-        Node n1 = _gr.u(min_edge1),
-             n2 = _gr.v(min_edge1);
-        path_dq.push_back(n1);
-        path_dq.push_back(n2);
-
-        FullGraph::NodeMap<bool> used(_gr, false);
-        used[n1] = true;
-        used[n2] = true;
-
-        min_edge1 = INVALID;
-        while (int(path_dq.size()) != _gr.nodeNum()) {
-          if (min_edge1 == INVALID) {
-            for (IncEdgeIt e(_gr, n1); e != INVALID; ++e) {
-              if (!used[_gr.runningNode(e)] &&
-                  (_cost[e] < _cost[min_edge1] || min_edge1 == INVALID)) {
-                min_edge1 = e;
-              }
-            }
-          }
-
-          if (min_edge2 == INVALID) {
-            for (IncEdgeIt e(_gr, n2); e != INVALID; ++e) {
-              if (!used[_gr.runningNode(e)] &&
-                  (_cost[e] < _cost[min_edge2] || min_edge2 == INVALID)) {
-                min_edge2 = e;
-              }
-            }
-          }
-
-          if (_cost[min_edge1] < _cost[min_edge2]) {
-            n1 = _gr.oppositeNode(n1, min_edge1);
-            path_dq.push_front(n1);
-
-            used[n1] = true;
-            min_edge1 = INVALID;
-
-            if (_gr.u(min_edge2) == n1 || _gr.v(min_edge2) == n1)
-              min_edge2 = INVALID;
-          } else {
-            n2 = _gr.oppositeNode(n2, min_edge2);
-            path_dq.push_back(n2);
-
-            used[n2] = true;
-            min_edge2 = INVALID;
-
-            if (_gr.u(min_edge1) == n2 || _gr.v(min_edge1) == n2)
-              min_edge1 = INVALID;
-          }
-        }
-
-        n1 = path_dq.back();
-        n2 = path_dq.front();
-        _path.push_back(n2);
-        _sum = _cost[_gr.edge(n1, n2)];
-        for (int i = 1; i < int(path_dq.size()); ++i) {
-          n1 = n2;
-          n2 = path_dq[i];
-          _path.push_back(n2);
-          _sum += _cost[_gr.edge(n1, n2)];
-        }
-
-        return _sum;
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-
-      /// @}
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 1254)
+++ lemon/network_simplex.h	(revision 976)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -41,16 +41,13 @@
   ///
   /// \ref NetworkSimplex implements the primal Network Simplex algorithm
-  /// for finding a \ref min_cost_flow "minimum cost flow"
-  /// \cite amo93networkflows, \cite dantzig63linearprog,
-  /// \cite kellyoneill91netsimplex.
-  /// This algorithm is a highly efficient specialized version of the
-  /// linear programming simplex method directly for the minimum cost
-  /// flow problem.
+  /// for finding a \ref min_cost_flow "minimum cost flow".
+  /// This algorithm is a specialized version of the linear programming
+  /// simplex method directly for the minimum cost flow problem.
+  /// It is one of the most efficient solution methods.
   ///
-  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
-  /// implementations available in LEMON for solving this problem.
-  /// (For more information, see \ref min_cost_flow_algs "the module page".)
-  /// Furthermore, this class supports both directions of the supply/demand
-  /// inequality constraints. For more information, see \ref SupplyType.
+  /// In general this class is the fastest implementation available
+  /// in LEMON for the minimum cost flow problem.
+  /// Moreover it supports both directions of the supply/demand inequality
+  /// constraints. For more information see \ref SupplyType.
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -60,16 +57,15 @@
   ///
   /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
+  /// \tparam V The value type used for flow amounts, capacity bounds
+  /// and supply values in the algorithm. By default it is \c int.
+  /// \tparam C The value type used for costs and potentials in the
+  /// algorithm. By default it is the same as \c V.
   ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
+  /// \warning Both value types must be signed and all input data must
   /// be integer.
   ///
   /// \note %NetworkSimplex provides five different pivot rule
   /// implementations, from which the most efficient one is used
-  /// by default. For more information, see \ref PivotRule.
+  /// by default. For more information see \ref PivotRule.
   template <typename GR, typename V = int, typename C = V>
   class NetworkSimplex
@@ -100,5 +96,5 @@
       UNBOUNDED
     };
-
+    
     /// \brief Constants for selecting the type of the supply constraints.
     ///
@@ -118,5 +114,5 @@
       LEQ
     };
-
+    
     /// \brief Constants for selecting the pivot rule.
     ///
@@ -124,27 +120,24 @@
     /// the \ref run() function.
     ///
-    /// \ref NetworkSimplex provides five different implementations for
-    /// the pivot strategy that significantly affects the running time
+    /// \ref NetworkSimplex provides five different pivot rule
+    /// implementations that significantly affect the running time
     /// of the algorithm.
-    /// According to experimental tests conducted on various problem
-    /// instances, \ref BLOCK_SEARCH "Block Search" and
-    /// \ref ALTERING_LIST "Altering Candidate List" rules turned out
-    /// to be the most efficient.
-    /// Since \ref BLOCK_SEARCH "Block Search" is a simpler strategy that
-    /// seemed to be slightly more robust, it is used by default.
-    /// However, another pivot rule can easily be selected using the
-    /// \ref run() function with the proper parameter.
+    /// By default \ref BLOCK_SEARCH "Block Search" is used, which
+    /// proved to be the most efficient and the most robust on various
+    /// test inputs according to our benchmark tests.
+    /// However another pivot rule can be selected using the \ref run()
+    /// function with the proper parameter.
     enum PivotRule {
 
-      /// The \e First \e Eligible pivot rule.
+      /// The First Eligible pivot rule.
       /// The next eligible arc is selected in a wraparound fashion
       /// in every iteration.
       FIRST_ELIGIBLE,
 
-      /// The \e Best \e Eligible pivot rule.
+      /// The Best Eligible pivot rule.
       /// The best eligible arc is selected in every iteration.
       BEST_ELIGIBLE,
 
-      /// The \e Block \e Search pivot rule.
+      /// The Block Search pivot rule.
       /// A specified number of arcs are examined in every iteration
       /// in a wraparound fashion and the best eligible arc is selected
@@ -152,5 +145,5 @@
       BLOCK_SEARCH,
 
-      /// The \e Candidate \e List pivot rule.
+      /// The Candidate List pivot rule.
       /// In a major iteration a candidate list is built from eligible arcs
       /// in a wraparound fashion and in the following minor iterations
@@ -158,33 +151,27 @@
       CANDIDATE_LIST,
 
-      /// The \e Altering \e Candidate \e List pivot rule.
+      /// The Altering Candidate List pivot rule.
       /// It is a modified version of the Candidate List method.
-      /// It keeps only a few of the best eligible arcs from the former
+      /// It keeps only the several best eligible arcs from the former
       /// candidate list and extends this list in every iteration.
       ALTERING_LIST
     };
-
+    
   private:
 
     TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 
+    typedef std::vector<Arc> ArcVector;
+    typedef std::vector<Node> NodeVector;
     typedef std::vector<int> IntVector;
+    typedef std::vector<bool> BoolVector;
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
-    typedef std::vector<signed char> CharVector;
-    // Note: vector<signed char> is used instead of vector<ArcState> and
-    // vector<ArcDirection> for efficiency reasons
 
     // State constants for arcs
-    enum ArcState {
+    enum ArcStateEnum {
       STATE_UPPER = -1,
       STATE_TREE  =  0,
       STATE_LOWER =  1
-    };
-
-    // Direction constants for tree arcs
-    enum ArcDirection {
-      DIR_DOWN = -1,
-      DIR_UP   =  1
     };
 
@@ -208,5 +195,4 @@
     IntVector _source;
     IntVector _target;
-    bool _arc_mixing;
 
     // Node and arc data
@@ -226,17 +212,17 @@
     IntVector _succ_num;
     IntVector _last_succ;
-    CharVector _pred_dir;
-    CharVector _state;
     IntVector _dirty_revs;
+    BoolVector _forward;
+    IntVector _state;
     int _root;
 
     // Temporary data used in the current pivot iteration
     int in_arc, join, u_in, v_in, u_out, v_out;
+    int first, second, right, last;
+    int stem, par_stem, new_stem;
     Value delta;
 
-    const Value MAX;
-
   public:
-
+  
     /// \brief Constant for infinite upper bounds (capacities).
     ///
@@ -257,5 +243,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -278,5 +264,5 @@
       bool findEnteringArc() {
         Cost c;
-        for (int e = _next_arc; e != _search_arc_num; ++e) {
+        for (int e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -286,5 +272,5 @@
           }
         }
-        for (int e = 0; e != _next_arc; ++e) {
+        for (int e = 0; e < _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -309,5 +295,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -326,5 +312,5 @@
       bool findEnteringArc() {
         Cost c, min = 0;
-        for (int e = 0; e != _search_arc_num; ++e) {
+        for (int e = 0; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
@@ -348,5 +334,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -367,5 +353,5 @@
       {
         // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
+        const double BLOCK_SIZE_FACTOR = 0.5;
         const int MIN_BLOCK_SIZE = 10;
 
@@ -379,30 +365,31 @@
         Cost c, min = 0;
         int cnt = _block_size;
-        int e;
-        for (e = _next_arc; e != _search_arc_num; ++e) {
+        int e, min_arc = _next_arc;
+        for (e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
             min = c;
-            _in_arc = e;
+            min_arc = e;
           }
           if (--cnt == 0) {
-            if (min < 0) goto search_end;
+            if (min < 0) break;
             cnt = _block_size;
           }
         }
-        for (e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < min) {
-            min = c;
-            _in_arc = e;
-          }
-          if (--cnt == 0) {
-            if (min < 0) goto search_end;
-            cnt = _block_size;
+        if (min == 0 || cnt > 0) {
+          for (e = 0; e < _next_arc; ++e) {
+            c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (c < min) {
+              min = c;
+              min_arc = e;
+            }
+            if (--cnt == 0) {
+              if (min < 0) break;
+              cnt = _block_size;
+            }
           }
         }
         if (min >= 0) return false;
-
-      search_end:
+        _in_arc = min_arc;
         _next_arc = e;
         return true;
@@ -421,5 +408,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -442,5 +429,5 @@
       {
         // The main parameters of the pivot rule
-        const double LIST_LENGTH_FACTOR = 0.25;
+        const double LIST_LENGTH_FACTOR = 1.0;
         const int MIN_LIST_LENGTH = 10;
         const double MINOR_LIMIT_FACTOR = 0.1;
@@ -459,5 +446,5 @@
       bool findEnteringArc() {
         Cost min, c;
-        int e;
+        int e, min_arc = _next_arc;
         if (_curr_length > 0 && _minor_count < _minor_limit) {
           // Minor iteration: select the best eligible arc from the
@@ -470,11 +457,14 @@
             if (c < min) {
               min = c;
-              _in_arc = e;
+              min_arc = e;
             }
-            else if (c >= 0) {
+            if (c >= 0) {
               _candidates[i--] = _candidates[--_curr_length];
             }
           }
-          if (min < 0) return true;
+          if (min < 0) {
+            _in_arc = min_arc;
+            return true;
+          }
         }
 
@@ -482,5 +472,5 @@
         min = 0;
         _curr_length = 0;
-        for (e = _next_arc; e != _search_arc_num; ++e) {
+        for (e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -488,24 +478,25 @@
             if (c < min) {
               min = c;
-              _in_arc = e;
+              min_arc = e;
             }
-            if (_curr_length == _list_length) goto search_end;
-          }
-        }
-        for (e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _candidates[_curr_length++] = e;
-            if (c < min) {
-              min = c;
-              _in_arc = e;
+            if (_curr_length == _list_length) break;
+          }
+        }
+        if (_curr_length < _list_length) {
+          for (e = 0; e < _next_arc; ++e) {
+            c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (c < 0) {
+              _candidates[_curr_length++] = e;
+              if (c < min) {
+                min = c;
+                min_arc = e;
+              }
+              if (_curr_length == _list_length) break;
             }
-            if (_curr_length == _list_length) goto search_end;
           }
         }
         if (_curr_length == 0) return false;
-
-      search_end:
         _minor_count = 1;
+        _in_arc = min_arc;
         _next_arc = e;
         return true;
@@ -524,5 +515,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -543,5 +534,5 @@
         SortFunc(const CostVector &map) : _map(map) {}
         bool operator()(int left, int right) {
-          return _map[left] < _map[right];
+          return _map[left] > _map[right];
         }
       };
@@ -559,7 +550,7 @@
       {
         // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
+        const double BLOCK_SIZE_FACTOR = 1.5;
         const int MIN_BLOCK_SIZE = 10;
-        const double HEAD_LENGTH_FACTOR = 0.01;
+        const double HEAD_LENGTH_FACTOR = 0.1;
         const int MIN_HEAD_LENGTH = 3;
 
@@ -577,11 +568,9 @@
         // Check the current candidate list
         int e;
-        Cost c;
-        for (int i = 0; i != _curr_length; ++i) {
+        for (int i = 0; i < _curr_length; ++i) {
           e = _candidates[i];
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
-          } else {
+          _cand_cost[e] = _state[e] *
+            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (_cand_cost[e] >= 0) {
             _candidates[i--] = _candidates[--_curr_length];
           }
@@ -590,44 +579,47 @@
         // Extend the list
         int cnt = _block_size;
+        int last_arc = 0;
         int limit = _head_length;
 
-        for (e = _next_arc; e != _search_arc_num; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
+        for (int e = _next_arc; e < _search_arc_num; ++e) {
+          _cand_cost[e] = _state[e] *
+            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (_cand_cost[e] < 0) {
             _candidates[_curr_length++] = e;
+            last_arc = e;
           }
           if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
+            if (_curr_length > limit) break;
             limit = 0;
             cnt = _block_size;
           }
         }
-        for (e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
-            _candidates[_curr_length++] = e;
-          }
-          if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
-            limit = 0;
-            cnt = _block_size;
+        if (_curr_length <= limit) {
+          for (int e = 0; e < _next_arc; ++e) {
+            _cand_cost[e] = _state[e] *
+              (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (_cand_cost[e] < 0) {
+              _candidates[_curr_length++] = e;
+              last_arc = e;
+            }
+            if (--cnt == 0) {
+              if (_curr_length > limit) break;
+              limit = 0;
+              cnt = _block_size;
+            }
           }
         }
         if (_curr_length == 0) return false;
-
-      search_end:
-
-        // Perform partial sort operation on the candidate list
-        int new_length = std::min(_head_length + 1, _curr_length);
-        std::partial_sort(_candidates.begin(), _candidates.begin() + new_length,
-                          _candidates.begin() + _curr_length, _sort_func);
-
-        // Select the entering arc and remove it from the list
+        _next_arc = last_arc + 1;
+
+        // Make heap of the candidate list (approximating a partial sort)
+        make_heap( _candidates.begin(), _candidates.begin() + _curr_length,
+                   _sort_func );
+
+        // Pop the first element of the heap
         _in_arc = _candidates[0];
-        _next_arc = e;
-        _candidates[0] = _candidates[new_length - 1];
-        _curr_length = new_length - 1;
+        pop_heap( _candidates.begin(), _candidates.begin() + _curr_length,
+                  _sort_func );
+        _curr_length = std::min(_head_length, _curr_length - 1);
         return true;
       }
@@ -642,24 +634,67 @@
     ///
     /// \param graph The digraph the algorithm runs on.
-    /// \param arc_mixing Indicate if the arcs will be stored in a
-    /// mixed order in the internal data structure.
-    /// In general, it leads to similar performance as using the original
-    /// arc order, but it makes the algorithm more robust and in special
-    /// cases, even significantly faster. Therefore, it is enabled by default.
-    NetworkSimplex(const GR& graph, bool arc_mixing = true) :
+    NetworkSimplex(const GR& graph) :
       _graph(graph), _node_id(graph), _arc_id(graph),
-      _arc_mixing(arc_mixing),
-      MAX(std::numeric_limits<Value>::max()),
       INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() : MAX)
+          std::numeric_limits<Value>::infinity() :
+          std::numeric_limits<Value>::max())
     {
-      // Check the number types
+      // Check the value types
       LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
         "The flow type of NetworkSimplex must be signed");
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
         "The cost type of NetworkSimplex must be signed");
-
-      // Reset data structures
-      reset();
+        
+      // Resize vectors
+      _node_num = countNodes(_graph);
+      _arc_num = countArcs(_graph);
+      int all_node_num = _node_num + 1;
+      int max_arc_num = _arc_num + 2 * _node_num;
+
+      _source.resize(max_arc_num);
+      _target.resize(max_arc_num);
+
+      _lower.resize(_arc_num);
+      _upper.resize(_arc_num);
+      _cap.resize(max_arc_num);
+      _cost.resize(max_arc_num);
+      _supply.resize(all_node_num);
+      _flow.resize(max_arc_num);
+      _pi.resize(all_node_num);
+
+      _parent.resize(all_node_num);
+      _pred.resize(all_node_num);
+      _forward.resize(all_node_num);
+      _thread.resize(all_node_num);
+      _rev_thread.resize(all_node_num);
+      _succ_num.resize(all_node_num);
+      _last_succ.resize(all_node_num);
+      _state.resize(max_arc_num);
+
+      // Copy the graph (store the arcs in a mixed order)
+      int i = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _node_id[n] = i;
+      }
+      int k = std::max(int(std::sqrt(double(_arc_num))), 10);
+      i = 0;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _arc_id[a] = i;
+        _source[i] = _node_id[_graph.source(a)];
+        _target[i] = _node_id[_graph.target(a)];
+        if ((i += k) >= _arc_num) i = (i % k) + 1;
+      }
+      
+      // Initialize maps
+      for (int i = 0; i != _node_num; ++i) {
+        _supply[i] = 0;
+      }
+      for (int i = 0; i != _arc_num; ++i) {
+        _lower[i] = 0;
+        _upper[i] = INF;
+        _cost[i] = 1;
+      }
+      _have_lower = false;
+      _stype = GEQ;
     }
 
@@ -695,5 +730,5 @@
     /// If it is not used before calling \ref run(), the upper bounds
     /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
+    /// unbounded from above on each arc).
     ///
     /// \param map An arc map storing the upper bounds.
@@ -734,4 +769,5 @@
     /// If neither this function nor \ref stSupply() is used before
     /// calling \ref run(), the supply of each node will be set to zero.
+    /// (It makes sense only if non-zero lower bounds are given.)
     ///
     /// \param map A node map storing the supply values.
@@ -740,6 +776,4 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \sa supplyType()
     template<typename SupplyMap>
     NetworkSimplex& supplyMap(const SupplyMap& map) {
@@ -756,7 +790,8 @@
     /// If neither this function nor \ref supplyMap() is used before
     /// calling \ref run(), the supply of each node will be set to zero.
+    /// (It makes sense only if non-zero lower bounds are given.)
     ///
     /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// with such a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
@@ -775,5 +810,5 @@
       return *this;
     }
-
+    
     /// \brief Set the type of the supply constraints.
     ///
@@ -782,5 +817,5 @@
     /// type will be used.
     ///
-    /// For more information, see \ref SupplyType.
+    /// For more information see \ref SupplyType.
     ///
     /// \return <tt>(*this)</tt>
@@ -801,5 +836,5 @@
     /// This function runs the algorithm.
     /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), 
     /// \ref supplyType().
     /// For example,
@@ -810,13 +845,13 @@
     /// \endcode
     ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
+    /// This function can be called more than once. All the parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param pivot_rule The pivot rule that will be used during the
-    /// algorithm. For more information, see \ref PivotRule.
+    /// algorithm. For more information see \ref PivotRule.
     ///
     /// \return \c INFEASIBLE if no feasible flow exists,
@@ -829,5 +864,4 @@
     ///
     /// \see ProblemType, PivotRule
-    /// \see resetParams(), reset()
     ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) {
       if (!init()) return INFEASIBLE;
@@ -841,10 +875,9 @@
     /// \ref costMap(), \ref supplyMap(), \ref stSupply(), \ref supplyType().
     ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
+    /// It is useful for multiple run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// For example,
@@ -856,12 +889,12 @@
     ///     .supplyMap(sup).run();
     ///
-    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // Run again with modified cost map (reset() is not called,
     ///   // so only the cost map have to be set again)
     ///   cost[e] += 100;
     ///   ns.costMap(cost).run();
     ///
-    ///   // Run again from scratch using resetParams()
+    ///   // Run again from scratch using reset()
     ///   // (the lower bounds will be set to zero on all arcs)
-    ///   ns.resetParams();
+    ///   ns.reset();
     ///   ns.upperMap(capacity).costMap(cost)
     ///     .supplyMap(sup).run();
@@ -869,7 +902,5 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    NetworkSimplex& resetParams() {
+    NetworkSimplex& reset() {
       for (int i = 0; i != _node_num; ++i) {
         _supply[i] = 0;
@@ -885,81 +916,4 @@
     }
 
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
-    /// \ref supplyType().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    NetworkSimplex& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      int all_node_num = _node_num + 1;
-      int max_arc_num = _arc_num + 2 * _node_num;
-
-      _source.resize(max_arc_num);
-      _target.resize(max_arc_num);
-
-      _lower.resize(_arc_num);
-      _upper.resize(_arc_num);
-      _cap.resize(max_arc_num);
-      _cost.resize(max_arc_num);
-      _supply.resize(all_node_num);
-      _flow.resize(max_arc_num);
-      _pi.resize(all_node_num);
-
-      _parent.resize(all_node_num);
-      _pred.resize(all_node_num);
-      _pred_dir.resize(all_node_num);
-      _thread.resize(all_node_num);
-      _rev_thread.resize(all_node_num);
-      _succ_num.resize(all_node_num);
-      _last_succ.resize(all_node_num);
-      _state.resize(max_arc_num);
-
-      // Copy the graph
-      int i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      if (_arc_mixing) {
-        // Store the arcs in a mixed order
-        const int skip = std::max(_arc_num / _node_num, 3);
-        int i = 0, j = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-          if ((i += skip) >= _arc_num) i = ++j;
-        }
-      } else {
-        // Store the arcs in the original order
-        int i = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-        }
-      }
-
-      // Reset parameters
-      resetParams();
-      return *this;
-    }
-
     /// @}
 
@@ -974,5 +928,5 @@
     ///
     /// This function returns the total cost of the found flow.
-    /// Its complexity is O(m).
+    /// Its complexity is O(e).
     ///
     /// \note The return type of the function can be specified as a
@@ -1011,6 +965,5 @@
     }
 
-    /// \brief Copy the flow values (the primal solution) into the
-    /// given map.
+    /// \brief Return the flow map (the primal solution).
     ///
     /// This function copies the flow value on each arc into the given
@@ -1036,6 +989,5 @@
     }
 
-    /// \brief Copy the potential values (the dual solution) into the
-    /// given map.
+    /// \brief Return the potential map (the dual solution).
     ///
     /// This function copies the potential (dual value) of each node
@@ -1068,8 +1020,4 @@
              (_stype == LEQ && _sum_supply >= 0)) ) return false;
 
-      // Check lower and upper bounds
-      LEMON_DEBUG(checkBoundMaps(),
-          "Upper bounds must be greater or equal to the lower bounds");
-
       // Remove non-zero lower bounds
       if (_have_lower) {
@@ -1077,7 +1025,7 @@
           Value c = _lower[i];
           if (c >= 0) {
-            _cap[i] = _upper[i] < MAX ? _upper[i] - c : INF;
+            _cap[i] = _upper[i] < INF ? _upper[i] - c : INF;
           } else {
-            _cap[i] = _upper[i] < MAX + c ? _upper[i] - c : INF;
+            _cap[i] = _upper[i] < INF + c ? _upper[i] - c : INF;
           }
           _supply[_source[i]] -= c;
@@ -1107,5 +1055,5 @@
         _state[i] = STATE_LOWER;
       }
-
+      
       // Set data for the artificial root node
       _root = _node_num;
@@ -1134,5 +1082,5 @@
           _state[e] = STATE_TREE;
           if (_supply[u] >= 0) {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = 0;
             _source[e] = u;
@@ -1141,5 +1089,5 @@
             _cost[e] = 0;
           } else {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = ART_COST;
             _source[e] = _root;
@@ -1161,5 +1109,5 @@
           _last_succ[u] = u;
           if (_supply[u] >= 0) {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = 0;
             _pred[u] = e;
@@ -1171,5 +1119,5 @@
             _state[e] = STATE_TREE;
           } else {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = ART_COST;
             _pred[u] = f;
@@ -1202,5 +1150,5 @@
           _last_succ[u] = u;
           if (_supply[u] <= 0) {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = 0;
             _pred[u] = e;
@@ -1212,5 +1160,5 @@
             _state[e] = STATE_TREE;
           } else {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = -ART_COST;
             _pred[u] = f;
@@ -1235,13 +1183,4 @@
       return true;
     }
-    
-    // Check if the upper bound is greater or equal to the lower bound
-    // on each arc.
-    bool checkBoundMaps() {
-      for (int j = 0; j != _arc_num; ++j) {
-        if (_upper[j] < _lower[j]) return false;
-      }
-      return true;
-    }
 
     // Find the join node
@@ -1264,5 +1203,4 @@
       // Initialize first and second nodes according to the direction
       // of the cycle
-      int first, second;
       if (_state[in_arc] == STATE_LOWER) {
         first  = _source[in_arc];
@@ -1274,15 +1212,12 @@
       delta = _cap[in_arc];
       int result = 0;
-      Value c, d;
+      Value d;
       int e;
 
-      // Search the cycle form the first node to the join node
+      // Search the cycle along the path form the first node to the root
       for (int u = first; u != join; u = _parent[u]) {
         e = _pred[u];
-        d = _flow[e];
-        if (_pred_dir[u] == DIR_DOWN) {
-          c = _cap[e];
-          d = c >= MAX ? INF : c - d;
-        }
+        d = _forward[u] ?
+          _flow[e] : (_cap[e] == INF ? INF : _cap[e] - _flow[e]);
         if (d < delta) {
           delta = d;
@@ -1291,13 +1226,9 @@
         }
       }
-
-      // Search the cycle form the second node to the join node
+      // Search the cycle along the path form the second node to the root
       for (int u = second; u != join; u = _parent[u]) {
         e = _pred[u];
-        d = _flow[e];
-        if (_pred_dir[u] == DIR_UP) {
-          c = _cap[e];
-          d = c >= MAX ? INF : c - d;
-        }
+        d = _forward[u] ? 
+          (_cap[e] == INF ? INF : _cap[e] - _flow[e]) : _flow[e];
         if (d <= delta) {
           delta = d;
@@ -1324,8 +1255,8 @@
         _flow[in_arc] += val;
         for (int u = _source[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] -= _pred_dir[u] * val;
+          _flow[_pred[u]] += _forward[u] ? -val : val;
         }
         for (int u = _target[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] += _pred_dir[u] * val;
+          _flow[_pred[u]] += _forward[u] ? val : -val;
         }
       }
@@ -1342,4 +1273,5 @@
     // Update the tree structure
     void updateTreeStructure() {
+      int u, w;
       int old_rev_thread = _rev_thread[u_out];
       int old_succ_num = _succ_num[u_out];
@@ -1347,225 +1279,126 @@
       v_out = _parent[u_out];
 
-      // Check if u_in and u_out coincide
-      if (u_in == u_out) {
-        // Update _parent, _pred, _pred_dir
-        _parent[u_in] = v_in;
-        _pred[u_in] = in_arc;
-        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
-
-        // Update _thread and _rev_thread
-        if (_thread[v_in] != u_out) {
-          int after = _thread[old_last_succ];
-          _thread[old_rev_thread] = after;
-          _rev_thread[after] = old_rev_thread;
-          after = _thread[v_in];
-          _thread[v_in] = u_out;
-          _rev_thread[u_out] = v_in;
-          _thread[old_last_succ] = after;
-          _rev_thread[after] = old_last_succ;
-        }
+      u = _last_succ[u_in];  // the last successor of u_in
+      right = _thread[u];    // the node after it
+
+      // Handle the case when old_rev_thread equals to v_in
+      // (it also means that join and v_out coincide)
+      if (old_rev_thread == v_in) {
+        last = _thread[_last_succ[u_out]];
       } else {
-        // Handle the case when old_rev_thread equals to v_in
-        // (it also means that join and v_out coincide)
-        int thread_continue = old_rev_thread == v_in ?
-          _thread[old_last_succ] : _thread[v_in];
-
-        // Update _thread and _parent along the stem nodes (i.e. the nodes
-        // between u_in and u_out, whose parent have to be changed)
-        int stem = u_in;              // the current stem node
-        int par_stem = v_in;          // the new parent of stem
-        int next_stem;                // the next stem node
-        int last = _last_succ[u_in];  // the last successor of stem
-        int before, after = _thread[last];
-        _thread[v_in] = u_in;
-        _dirty_revs.clear();
-        _dirty_revs.push_back(v_in);
-        while (stem != u_out) {
-          // Insert the next stem node into the thread list
-          next_stem = _parent[stem];
-          _thread[last] = next_stem;
-          _dirty_revs.push_back(last);
-
-          // Remove the subtree of stem from the thread list
-          before = _rev_thread[stem];
-          _thread[before] = after;
-          _rev_thread[after] = before;
-
-          // Change the parent node and shift stem nodes
-          _parent[stem] = par_stem;
-          par_stem = stem;
-          stem = next_stem;
-
-          // Update last and after
-          last = _last_succ[stem] == _last_succ[par_stem] ?
-            _rev_thread[par_stem] : _last_succ[stem];
-          after = _thread[last];
-        }
-        _parent[u_out] = par_stem;
-        _thread[last] = thread_continue;
-        _rev_thread[thread_continue] = last;
-        _last_succ[u_out] = last;
-
-        // Remove the subtree of u_out from the thread list except for
-        // the case when old_rev_thread equals to v_in
-        if (old_rev_thread != v_in) {
-          _thread[old_rev_thread] = after;
-          _rev_thread[after] = old_rev_thread;
-        }
-
-        // Update _rev_thread using the new _thread values
-        for (int i = 0; i != int(_dirty_revs.size()); ++i) {
-          int u = _dirty_revs[i];
-          _rev_thread[_thread[u]] = u;
-        }
-
-        // Update _pred, _pred_dir, _last_succ and _succ_num for the
-        // stem nodes from u_out to u_in
-        int tmp_sc = 0, tmp_ls = _last_succ[u_out];
-        for (int u = u_out, p = _parent[u]; u != u_in; u = p, p = _parent[u]) {
-          _pred[u] = _pred[p];
-          _pred_dir[u] = -_pred_dir[p];
-          tmp_sc += _succ_num[u] - _succ_num[p];
-          _succ_num[u] = tmp_sc;
-          _last_succ[p] = tmp_ls;
-        }
-        _pred[u_in] = in_arc;
-        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
-        _succ_num[u_in] = old_succ_num;
+        last = _thread[v_in];
+      }
+
+      // Update _thread and _parent along the stem nodes (i.e. the nodes
+      // between u_in and u_out, whose parent have to be changed)
+      _thread[v_in] = stem = u_in;
+      _dirty_revs.clear();
+      _dirty_revs.push_back(v_in);
+      par_stem = v_in;
+      while (stem != u_out) {
+        // Insert the next stem node into the thread list
+        new_stem = _parent[stem];
+        _thread[u] = new_stem;
+        _dirty_revs.push_back(u);
+
+        // Remove the subtree of stem from the thread list
+        w = _rev_thread[stem];
+        _thread[w] = right;
+        _rev_thread[right] = w;
+
+        // Change the parent node and shift stem nodes
+        _parent[stem] = par_stem;
+        par_stem = stem;
+        stem = new_stem;
+
+        // Update u and right
+        u = _last_succ[stem] == _last_succ[par_stem] ?
+          _rev_thread[par_stem] : _last_succ[stem];
+        right = _thread[u];
+      }
+      _parent[u_out] = par_stem;
+      _thread[u] = last;
+      _rev_thread[last] = u;
+      _last_succ[u_out] = u;
+
+      // Remove the subtree of u_out from the thread list except for
+      // the case when old_rev_thread equals to v_in
+      // (it also means that join and v_out coincide)
+      if (old_rev_thread != v_in) {
+        _thread[old_rev_thread] = right;
+        _rev_thread[right] = old_rev_thread;
+      }
+
+      // Update _rev_thread using the new _thread values
+      for (int i = 0; i < int(_dirty_revs.size()); ++i) {
+        u = _dirty_revs[i];
+        _rev_thread[_thread[u]] = u;
+      }
+
+      // Update _pred, _forward, _last_succ and _succ_num for the
+      // stem nodes from u_out to u_in
+      int tmp_sc = 0, tmp_ls = _last_succ[u_out];
+      u = u_out;
+      while (u != u_in) {
+        w = _parent[u];
+        _pred[u] = _pred[w];
+        _forward[u] = !_forward[w];
+        tmp_sc += _succ_num[u] - _succ_num[w];
+        _succ_num[u] = tmp_sc;
+        _last_succ[w] = tmp_ls;
+        u = w;
+      }
+      _pred[u_in] = in_arc;
+      _forward[u_in] = (u_in == _source[in_arc]);
+      _succ_num[u_in] = old_succ_num;
+
+      // Set limits for updating _last_succ form v_in and v_out
+      // towards the root
+      int up_limit_in = -1;
+      int up_limit_out = -1;
+      if (_last_succ[join] == v_in) {
+        up_limit_out = join;
+      } else {
+        up_limit_in = join;
       }
 
       // Update _last_succ from v_in towards the root
-      int up_limit_out = _last_succ[join] == v_in ? join : -1;
-      int last_succ_out = _last_succ[u_out];
-      for (int u = v_in; u != -1 && _last_succ[u] == v_in; u = _parent[u]) {
-        _last_succ[u] = last_succ_out;
-      }
-
+      for (u = v_in; u != up_limit_in && _last_succ[u] == v_in;
+           u = _parent[u]) {
+        _last_succ[u] = _last_succ[u_out];
+      }
       // Update _last_succ from v_out towards the root
       if (join != old_rev_thread && v_in != old_rev_thread) {
-        for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
+        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
              u = _parent[u]) {
           _last_succ[u] = old_rev_thread;
         }
-      }
-      else if (last_succ_out != old_last_succ) {
-        for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
+      } else {
+        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
              u = _parent[u]) {
-          _last_succ[u] = last_succ_out;
+          _last_succ[u] = _last_succ[u_out];
         }
       }
 
       // Update _succ_num from v_in to join
-      for (int u = v_in; u != join; u = _parent[u]) {
+      for (u = v_in; u != join; u = _parent[u]) {
         _succ_num[u] += old_succ_num;
       }
       // Update _succ_num from v_out to join
-      for (int u = v_out; u != join; u = _parent[u]) {
+      for (u = v_out; u != join; u = _parent[u]) {
         _succ_num[u] -= old_succ_num;
       }
     }
 
-    // Update potentials in the subtree that has been moved
+    // Update potentials
     void updatePotential() {
-      Cost sigma = _pi[v_in] - _pi[u_in] -
-                   _pred_dir[u_in] * _cost[in_arc];
+      Cost sigma = _forward[u_in] ?
+        _pi[v_in] - _pi[u_in] - _cost[_pred[u_in]] :
+        _pi[v_in] - _pi[u_in] + _cost[_pred[u_in]];
+      // Update potentials in the subtree, which has been moved
       int end = _thread[_last_succ[u_in]];
       for (int u = u_in; u != end; u = _thread[u]) {
         _pi[u] += sigma;
       }
-    }
-
-    // Heuristic initial pivots
-    bool initialPivots() {
-      Value curr, total = 0;
-      std::vector<Node> supply_nodes, demand_nodes;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        curr = _supply[_node_id[u]];
-        if (curr > 0) {
-          total += curr;
-          supply_nodes.push_back(u);
-        }
-        else if (curr < 0) {
-          demand_nodes.push_back(u);
-        }
-      }
-      if (_sum_supply > 0) total -= _sum_supply;
-      if (total <= 0) return true;
-
-      IntVector arc_vector;
-      if (_sum_supply >= 0) {
-        if (supply_nodes.size() == 1 && demand_nodes.size() == 1) {
-          // Perform a reverse graph search from the sink to the source
-          typename GR::template NodeMap<bool> reached(_graph, false);
-          Node s = supply_nodes[0], t = demand_nodes[0];
-          std::vector<Node> stack;
-          reached[t] = true;
-          stack.push_back(t);
-          while (!stack.empty()) {
-            Node u, v = stack.back();
-            stack.pop_back();
-            if (v == s) break;
-            for (InArcIt a(_graph, v); a != INVALID; ++a) {
-              if (reached[u = _graph.source(a)]) continue;
-              int j = _arc_id[a];
-              if (_cap[j] >= total) {
-                arc_vector.push_back(j);
-                reached[u] = true;
-                stack.push_back(u);
-              }
-            }
-          }
-        } else {
-          // Find the min. cost incoming arc for each demand node
-          for (int i = 0; i != int(demand_nodes.size()); ++i) {
-            Node v = demand_nodes[i];
-            Cost c, min_cost = std::numeric_limits<Cost>::max();
-            Arc min_arc = INVALID;
-            for (InArcIt a(_graph, v); a != INVALID; ++a) {
-              c = _cost[_arc_id[a]];
-              if (c < min_cost) {
-                min_cost = c;
-                min_arc = a;
-              }
-            }
-            if (min_arc != INVALID) {
-              arc_vector.push_back(_arc_id[min_arc]);
-            }
-          }
-        }
-      } else {
-        // Find the min. cost outgoing arc for each supply node
-        for (int i = 0; i != int(supply_nodes.size()); ++i) {
-          Node u = supply_nodes[i];
-          Cost c, min_cost = std::numeric_limits<Cost>::max();
-          Arc min_arc = INVALID;
-          for (OutArcIt a(_graph, u); a != INVALID; ++a) {
-            c = _cost[_arc_id[a]];
-            if (c < min_cost) {
-              min_cost = c;
-              min_arc = a;
-            }
-          }
-          if (min_arc != INVALID) {
-            arc_vector.push_back(_arc_id[min_arc]);
-          }
-        }
-      }
-
-      // Perform heuristic initial pivots
-      for (int i = 0; i != int(arc_vector.size()); ++i) {
-        in_arc = arc_vector[i];
-        if (_state[in_arc] * (_cost[in_arc] + _pi[_source[in_arc]] -
-            _pi[_target[in_arc]]) >= 0) continue;
-        findJoinNode();
-        bool change = findLeavingArc();
-        if (delta >= MAX) return false;
-        changeFlow(change);
-        if (change) {
-          updateTreeStructure();
-          updatePotential();
-        }
-      }
-      return true;
     }
 
@@ -1592,12 +1425,9 @@
       PivotRuleImpl pivot(*this);
 
-      // Perform heuristic initial pivots
-      if (!initialPivots()) return UNBOUNDED;
-
       // Execute the Network Simplex algorithm
       while (pivot.findEnteringArc()) {
         findJoinNode();
         bool change = findLeavingArc();
-        if (delta >= MAX) return UNBOUNDED;
+        if (delta >= INF) return UNBOUNDED;
         changeFlow(change);
         if (change) {
@@ -1606,5 +1436,5 @@
         }
       }
-
+      
       // Check feasibility
       for (int e = _search_arc_num; e != _all_arc_num; ++e) {
@@ -1623,5 +1453,5 @@
         }
       }
-
+      
       // Shift potentials to meet the requirements of the GEQ/LEQ type
       // optimality conditions
Index: lemon/opt2_tsp.h
===================================================================
--- lemon/opt2_tsp.h	(revision 1250)
+++ 	(revision )
@@ -1,367 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_OPT2_TSP_H
-#define LEMON_OPT2_TSP_H
-
-/// \ingroup tsp
-/// \file
-/// \brief 2-opt algorithm for symmetric TSP.
-
-#include <vector>
-#include <lemon/full_graph.h>
-
-namespace lemon {
-
-  /// \ingroup tsp
-  ///
-  /// \brief 2-opt algorithm for symmetric TSP.
-  ///
-  /// Opt2Tsp implements the 2-opt heuristic for solving
-  /// symmetric \ref tsp "TSP".
-  ///
-  /// This algorithm starts with an initial tour and iteratively improves it.
-  /// At each step, it removes two edges and the reconnects the created two
-  /// paths in the other way if the resulting tour is shorter.
-  /// The algorithm finishes when no such 2-opt move can be applied, and so
-  /// the tour is 2-optimal.
-  ///
-  /// If no starting tour is given to the \ref run() function, then the
-  /// algorithm uses the node sequence determined by the node IDs.
-  /// Oherwise, it starts with the given tour.
-  ///
-  /// This is a rather slow but effective method.
-  /// Its typical usage is the improvement of the result of a fast tour
-  /// construction heuristic (e.g. the InsertionTsp algorithm).
-  ///
-  /// \tparam CM Type of the cost map.
-  template <typename CM>
-  class Opt2Tsp
-  {
-    public:
-
-      /// Type of the cost map
-      typedef CM CostMap;
-      /// Type of the edge costs
-      typedef typename CM::Value Cost;
-
-    private:
-
-      GRAPH_TYPEDEFS(FullGraph);
-
-      const FullGraph &_gr;
-      const CostMap &_cost;
-      Cost _sum;
-      std::vector<int> _plist;
-      std::vector<Node> _path;
-
-    public:
-
-      /// \brief Constructor
-      ///
-      /// Constructor.
-      /// \param gr The \ref FullGraph "full graph" the algorithm runs on.
-      /// \param cost The cost map.
-      Opt2Tsp(const FullGraph &gr, const CostMap &cost)
-        : _gr(gr), _cost(cost) {}
-
-      /// \name Execution Control
-      /// @{
-
-      /// \brief Runs the algorithm from scratch.
-      ///
-      /// This function runs the algorithm starting from the tour that is
-      /// determined by the node ID sequence.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run() {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-
-        _plist.resize(2*_gr.nodeNum());
-        for (int i = 1; i < _gr.nodeNum()-1; ++i) {
-          _plist[2*i] = i-1;
-          _plist[2*i+1] = i+1;
-        }
-        _plist[0] = _gr.nodeNum()-1;
-        _plist[1] = 1;
-        _plist[2*_gr.nodeNum()-2] = _gr.nodeNum()-2;
-        _plist[2*_gr.nodeNum()-1] = 0;
-
-        return start();
-      }
-
-      /// \brief Runs the algorithm starting from the given tour.
-      ///
-      /// This function runs the algorithm starting from the given tour.
-      ///
-      /// \param tour The tour as a path structure. It must be a
-      /// \ref checkPath() "valid path" containing excactly n arcs.
-      ///
-      /// \return The total cost of the found tour.
-      template <typename Path>
-      Cost run(const Path& tour) {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-
-        _plist.resize(2*_gr.nodeNum());
-        typename Path::ArcIt it(tour);
-        int first = _gr.id(_gr.source(it)),
-            prev = first,
-            curr = _gr.id(_gr.target(it)),
-            next = -1;
-        _plist[2*first+1] = curr;
-        for (++it; it != INVALID; ++it) {
-          next = _gr.id(_gr.target(it));
-          _plist[2*curr] = prev;
-          _plist[2*curr+1] = next;
-          prev = curr;
-          curr = next;
-        }
-        _plist[2*first] = prev;
-
-        return start();
-      }
-
-      /// \brief Runs the algorithm starting from the given tour.
-      ///
-      /// This function runs the algorithm starting from the given tour
-      /// (node sequence).
-      ///
-      /// \param tour A vector that stores all <tt>Node</tt>s of the graph
-      /// in the desired order.
-      ///
-      /// \return The total cost of the found tour.
-      Cost run(const std::vector<Node>& tour) {
-        _path.clear();
-
-        if (_gr.nodeNum() == 0) return _sum = 0;
-        else if (_gr.nodeNum() == 1) {
-          _path.push_back(_gr(0));
-          return _sum = 0;
-        }
-        else if (_gr.nodeNum() == 2) {
-          _path.push_back(_gr(0));
-          _path.push_back(_gr(1));
-          return _sum = 2 * _cost[_gr.edge(_gr(0), _gr(1))];
-        }
-
-        _plist.resize(2*_gr.nodeNum());
-        typename std::vector<Node>::const_iterator it = tour.begin();
-        int first = _gr.id(*it),
-            prev = first,
-            curr = _gr.id(*(++it)),
-            next = -1;
-        _plist[2*first+1] = curr;
-        for (++it; it != tour.end(); ++it) {
-          next = _gr.id(*it);
-          _plist[2*curr] = prev;
-          _plist[2*curr+1] = next;
-          prev = curr;
-          curr = next;
-        }
-        _plist[2*first] = curr;
-        _plist[2*curr] = prev;
-        _plist[2*curr+1] = first;
-
-        return start();
-      }
-
-      /// @}
-
-      /// \name Query Functions
-      /// @{
-
-      /// \brief The total cost of the found tour.
-      ///
-      /// This function returns the total cost of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      Cost tourCost() const {
-        return _sum;
-      }
-
-      /// \brief Returns a const reference to the node sequence of the
-      /// found tour.
-      ///
-      /// This function returns a const reference to a vector
-      /// that stores the node sequence of the found tour.
-      ///
-      /// \pre run() must be called before using this function.
-      const std::vector<Node>& tourNodes() const {
-        return _path;
-      }
-
-      /// \brief Gives back the node sequence of the found tour.
-      ///
-      /// This function copies the node sequence of the found tour into
-      /// an STL container through the given output iterator. The
-      /// <tt>value_type</tt> of the container must be <tt>FullGraph::Node</tt>.
-      /// For example,
-      /// \code
-      /// std::vector<FullGraph::Node> nodes(countNodes(graph));
-      /// tsp.tourNodes(nodes.begin());
-      /// \endcode
-      /// or
-      /// \code
-      /// std::list<FullGraph::Node> nodes;
-      /// tsp.tourNodes(std::back_inserter(nodes));
-      /// \endcode
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Iterator>
-      void tourNodes(Iterator out) const {
-        std::copy(_path.begin(), _path.end(), out);
-      }
-
-      /// \brief Gives back the found tour as a path.
-      ///
-      /// This function copies the found tour as a list of arcs/edges into
-      /// the given \ref lemon::concepts::Path "path structure".
-      ///
-      /// \pre run() must be called before using this function.
-      template <typename Path>
-      void tour(Path &path) const {
-        path.clear();
-        for (int i = 0; i < int(_path.size()) - 1; ++i) {
-          path.addBack(_gr.arc(_path[i], _path[i+1]));
-        }
-        if (int(_path.size()) >= 2) {
-          path.addBack(_gr.arc(_path.back(), _path.front()));
-        }
-      }
-
-      /// @}
-
-    private:
-
-      // Iterator class for the linked list storage of the tour
-      class PathListIt {
-        public:
-          PathListIt(const std::vector<int> &pl, int i=0)
-            : plist(&pl), act(i), last(pl[2*act]) {}
-          PathListIt(const std::vector<int> &pl, int i, int l)
-            : plist(&pl), act(i), last(l) {}
-
-          int nextIndex() const {
-            return (*plist)[2*act] == last ? 2*act+1 : 2*act;
-          }
-
-          int prevIndex() const {
-            return (*plist)[2*act] == last ? 2*act : 2*act+1;
-          }
-
-          int next() const {
-            int x = (*plist)[2*act];
-            return x == last ? (*plist)[2*act+1] : x;
-          }
-
-          int prev() const {
-            return last;
-          }
-
-          PathListIt& operator++() {
-            int tmp = act;
-            act = next();
-            last = tmp;
-            return *this;
-          }
-
-          operator int() const {
-            return act;
-          }
-
-        private:
-          const std::vector<int> *plist;
-          int act;
-          int last;
-      };
-
-      // Checks and applies 2-opt move (if it improves the tour)
-      bool checkOpt2(const PathListIt& i, const PathListIt& j) {
-        Node u  = _gr.nodeFromId(i),
-             un = _gr.nodeFromId(i.next()),
-             v  = _gr.nodeFromId(j),
-             vn = _gr.nodeFromId(j.next());
-
-        if (_cost[_gr.edge(u, un)] + _cost[_gr.edge(v, vn)] >
-            _cost[_gr.edge(u, v)] + _cost[_gr.edge(un, vn)])
-        {
-          _plist[PathListIt(_plist, i.next(), i).prevIndex()] = j.next();
-          _plist[PathListIt(_plist, j.next(), j).prevIndex()] = i.next();
-
-          _plist[i.nextIndex()] = j;
-          _plist[j.nextIndex()] = i;
-
-          return true;
-        }
-
-        return false;
-     }
-
-      // Executes the algorithm from the initial tour
-      Cost start() {
-
-      restart_search:
-        for (PathListIt i(_plist); true; ++i) {
-          PathListIt j = i;
-          if (++j == 0 || ++j == 0) break;
-          for (; j != 0 && j != i.prev(); ++j) {
-            if (checkOpt2(i, j))
-              goto restart_search;
-          }
-        }
-
-        PathListIt i(_plist);
-        _path.push_back(_gr.nodeFromId(i));
-        for (++i; i != 0; ++i)
-          _path.push_back(_gr.nodeFromId(i));
-
-        _sum = _cost[_gr.edge(_path.back(), _path.front())];
-        for (int i = 0; i < int(_path.size())-1; ++i) {
-          _sum += _cost[_gr.edge(_path[i], _path[i+1])];
-        }
-
-        return _sum;
-      }
-
-  };
-
-}; // namespace lemon
-
-#endif
Index: lemon/pairing_heap.h
===================================================================
--- lemon/pairing_heap.h	(revision 752)
+++ 	(revision )
@@ -1,474 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_PAIRING_HEAP_H
-#define LEMON_PAIRING_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Pairing heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-#include <lemon/math.h>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Pairing Heap.
-  ///
-  /// This class implements the \e pairing \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The methods \ref increase() and \ref erase() are not efficient
-  /// in a pairing heap. In case of many calls of these operations,
-  /// it is better to use other heap structure, e.g. \ref BinHeap
-  /// "binary heap".
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class PairingHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    class store;
-
-    std::vector<store> _data;
-    int _min;
-    ItemIntMap &_iim;
-    Compare _comp;
-    int _num_items;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit PairingHeap(ItemIntMap &map)
-      : _min(0), _iim(map), _num_items(0) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    PairingHeap(ItemIntMap &map, const Compare &comp)
-      : _min(0), _iim(map), _comp(comp), _num_items(0) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _num_items; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _num_items==0; }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() {
-      _data.clear();
-      _min = 0;
-      _num_items = 0;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param item The item.
-    /// \param value The priority.
-    void set (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i>=0 && _data[i].in ) {
-        if ( _comp(value, _data[i].prio) ) decrease(item, value);
-        if ( _comp(_data[i].prio, value) ) increase(item, value);
-      } else push(item, value);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param item The item to insert.
-    /// \param value The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if( i<0 ) {
-        int s=_data.size();
-        _iim.set(item, s);
-        store st;
-        st.name=item;
-        _data.push_back(st);
-        i=s;
-      } else {
-        _data[i].parent=_data[i].child=-1;
-        _data[i].left_child=false;
-        _data[i].degree=0;
-        _data[i].in=true;
-      }
-
-      _data[i].prio=value;
-
-      if ( _num_items!=0 ) {
-        if ( _comp( value, _data[_min].prio) ) {
-          fuse(i,_min);
-          _min=i;
-        }
-        else fuse(_min,i);
-      }
-      else _min=i;
-
-      ++_num_items;
-    }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[_min].name; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    const Prio& prio() const { return _data[_min].prio; }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    const Prio& operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      std::vector<int> trees;
-      int i=0, child_right = 0;
-      _data[_min].in=false;
-
-      if( -1!=_data[_min].child ) {
-        i=_data[_min].child;
-        trees.push_back(i);
-        _data[i].parent = -1;
-        _data[_min].child = -1;
-
-        int ch=-1;
-        while( _data[i].child!=-1 ) {
-          ch=_data[i].child;
-          if( _data[ch].left_child && i==_data[ch].parent ) {
-            break;
-          } else {
-            if( _data[ch].left_child ) {
-              child_right=_data[ch].parent;
-              _data[ch].parent = i;
-              --_data[i].degree;
-            }
-            else {
-              child_right=ch;
-              _data[i].child=-1;
-              _data[i].degree=0;
-            }
-            _data[child_right].parent = -1;
-            trees.push_back(child_right);
-            i = child_right;
-          }
-        }
-
-        int num_child = trees.size();
-        int other;
-        for( i=0; i<num_child-1; i+=2 ) {
-          if ( !_comp(_data[trees[i]].prio, _data[trees[i+1]].prio) ) {
-            other=trees[i];
-            trees[i]=trees[i+1];
-            trees[i+1]=other;
-          }
-          fuse( trees[i], trees[i+1] );
-        }
-
-        i = (0==(num_child % 2)) ? num_child-2 : num_child-1;
-        while(i>=2) {
-          if ( _comp(_data[trees[i]].prio, _data[trees[i-2]].prio) ) {
-            other=trees[i];
-            trees[i]=trees[i-2];
-            trees[i-2]=other;
-          }
-          fuse( trees[i-2], trees[i] );
-          i-=2;
-        }
-        _min = trees[0];
-      }
-      else {
-        _min = _data[_min].child;
-      }
-
-      if (_min >= 0) _data[_min].left_child = false;
-      --_num_items;
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param item The item to delete.
-    /// \pre \e item must be in the heap.
-    void erase (const Item& item) {
-      int i=_iim[item];
-      if ( i>=0 && _data[i].in ) {
-        decrease( item, _data[_min].prio-1 );
-        pop();
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e value.
-    void decrease (Item item, const Prio& value) {
-      int i=_iim[item];
-      _data[i].prio=value;
-      int p=_data[i].parent;
-
-      if( _data[i].left_child && i!=_data[p].child ) {
-        p=_data[p].parent;
-      }
-
-      if ( p!=-1 && _comp(value,_data[p].prio) ) {
-        cut(i,p);
-        if ( _comp(_data[_min].prio,value) ) {
-          fuse(_min,i);
-        } else {
-          fuse(i,_min);
-          _min=i;
-        }
-      }
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e value.
-    void increase (Item item, const Prio& value) {
-      erase(item);
-      push(item,value);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param item The item.
-    State state(const Item &item) const {
-      int i=_iim[item];
-      if( i>=0 ) {
-        if( _data[i].in ) i=0;
-        else i=-2;
-      }
-      return State(i);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-      case POST_HEAP:
-      case PRE_HEAP:
-        if (state(i) == IN_HEAP) erase(i);
-        _iim[i]=st;
-        break;
-      case IN_HEAP:
-        break;
-      }
-    }
-
-  private:
-
-    void cut(int a, int b) {
-      int child_a;
-      switch (_data[a].degree) {
-        case 2:
-          child_a = _data[_data[a].child].parent;
-          if( _data[a].left_child ) {
-            _data[child_a].left_child=true;
-            _data[b].child=child_a;
-            _data[child_a].parent=_data[a].parent;
-          }
-          else {
-            _data[child_a].left_child=false;
-            _data[child_a].parent=b;
-            if( a!=_data[b].child )
-              _data[_data[b].child].parent=child_a;
-            else
-              _data[b].child=child_a;
-          }
-          --_data[a].degree;
-          _data[_data[a].child].parent=a;
-          break;
-
-        case 1:
-          child_a = _data[a].child;
-          if( !_data[child_a].left_child ) {
-            --_data[a].degree;
-            if( _data[a].left_child ) {
-              _data[child_a].left_child=true;
-              _data[child_a].parent=_data[a].parent;
-              _data[b].child=child_a;
-            }
-            else {
-              _data[child_a].left_child=false;
-              _data[child_a].parent=b;
-              if( a!=_data[b].child )
-                _data[_data[b].child].parent=child_a;
-              else
-                _data[b].child=child_a;
-            }
-            _data[a].child=-1;
-          }
-          else {
-            --_data[b].degree;
-            if( _data[a].left_child ) {
-              _data[b].child =
-                (1==_data[b].degree) ? _data[a].parent : -1;
-            } else {
-              if (1==_data[b].degree)
-                _data[_data[b].child].parent=b;
-              else
-                _data[b].child=-1;
-            }
-          }
-          break;
-
-        case 0:
-          --_data[b].degree;
-          if( _data[a].left_child ) {
-            _data[b].child =
-              (0!=_data[b].degree) ? _data[a].parent : -1;
-          } else {
-            if( 0!=_data[b].degree )
-              _data[_data[b].child].parent=b;
-            else
-              _data[b].child=-1;
-          }
-          break;
-      }
-      _data[a].parent=-1;
-      _data[a].left_child=false;
-    }
-
-    void fuse(int a, int b) {
-      int child_a = _data[a].child;
-      int child_b = _data[b].child;
-      _data[a].child=b;
-      _data[b].parent=a;
-      _data[b].left_child=true;
-
-      if( -1!=child_a ) {
-        _data[b].child=child_a;
-        _data[child_a].parent=b;
-        _data[child_a].left_child=false;
-        ++_data[b].degree;
-
-        if( -1!=child_b ) {
-           _data[b].child=child_b;
-           _data[child_b].parent=child_a;
-        }
-      }
-      else { ++_data[a].degree; }
-    }
-
-    class store {
-      friend class PairingHeap;
-
-      Item name;
-      int parent;
-      int child;
-      bool left_child;
-      int degree;
-      bool in;
-      Prio prio;
-
-      store() : parent(-1), child(-1), left_child(false), degree(0), in(true) {}
-    };
-  };
-
-} //namespace lemon
-
-#endif //LEMON_PAIRING_HEAP_H
-
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 1212)
+++ lemon/path.h	(revision 1144)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -44,5 +44,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence, it
+  /// lemon path type stores just this list. As a consequence, it
   /// cannot enumerate the nodes of the path and the source node of
   /// a zero length path is undefined.
@@ -149,5 +149,5 @@
     void clear() { head.clear(); tail.clear(); }
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -157,5 +157,5 @@
     }
 
-    /// \brief Initialize arc iterator to point to the n-th arc
+    /// \brief Initialize arc iterator to point to the nth arc
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -245,5 +245,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
@@ -318,5 +318,5 @@
       /// Constructor with starting point
       ArcIt(const SimplePath &_path, int _idx)
-        : path(&_path), idx(_idx) {}
+        : idx(_idx), path(&_path) {}
 
     public:
@@ -354,5 +354,5 @@
     void clear() { data.clear(); }
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -361,5 +361,5 @@
     }
 
-    /// \brief  Initializes arc iterator to point to the n-th arc.
+    /// \brief  Initializes arc iterator to point to the nth arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -422,5 +422,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
@@ -544,7 +544,7 @@
     };
 
-    /// \brief The n-th arc.
-    ///
-    /// This function looks for the n-th arc in O(n) time.
+    /// \brief The nth arc.
+    ///
+    /// This function looks for the nth arc in O(n) time.
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
@@ -556,5 +556,5 @@
     }
 
-    /// \brief Initializes arc iterator to point to the n-th arc.
+    /// \brief Initializes arc iterator to point to the nth arc.
     ArcIt nthIt(int n) const {
       Node *node = first;
@@ -775,5 +775,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the source node of
   /// a zero length path is undefined.
@@ -884,5 +884,5 @@
     };
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -891,5 +891,5 @@
     }
 
-    /// \brief The arc iterator pointing to the n-th arc.
+    /// \brief The arc iterator pointing to the nth arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -1019,5 +1019,5 @@
     };
 
-
+    
     template <typename From, typename To,
               bool revEnable = RevPathTagIndicator<From>::value>
@@ -1025,5 +1025,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorForward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -1032,5 +1032,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorBackward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -1095,5 +1095,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores only this list. As a consequence, it
+  /// lemon path type stores only this list. As a consequence, it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot have a source node.
Index: lemon/planarity.h
===================================================================
--- lemon/planarity.h	(revision 1160)
+++ 	(revision )
@@ -1,2754 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_PLANARITY_H
-#define LEMON_PLANARITY_H
-
-/// \ingroup planar
-/// \file
-/// \brief Planarity checking, embedding, drawing and coloring
-
-#include <vector>
-#include <list>
-
-#include <lemon/dfs.h>
-#include <lemon/bfs.h>
-#include <lemon/radix_sort.h>
-#include <lemon/maps.h>
-#include <lemon/path.h>
-#include <lemon/bucket_heap.h>
-#include <lemon/adaptors.h>
-#include <lemon/edge_set.h>
-#include <lemon/color.h>
-#include <lemon/dim2.h>
-
-namespace lemon {
-
-  namespace _planarity_bits {
-
-    template <typename Graph>
-    struct PlanarityVisitor : DfsVisitor<Graph> {
-
-      TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-      typedef typename Graph::template NodeMap<Arc> PredMap;
-
-      typedef typename Graph::template EdgeMap<bool> TreeMap;
-
-      typedef typename Graph::template NodeMap<int> OrderMap;
-      typedef std::vector<Node> OrderList;
-
-      typedef typename Graph::template NodeMap<int> LowMap;
-      typedef typename Graph::template NodeMap<int> AncestorMap;
-
-      PlanarityVisitor(const Graph& graph,
-                       PredMap& pred_map, TreeMap& tree_map,
-                       OrderMap& order_map, OrderList& order_list,
-                       AncestorMap& ancestor_map, LowMap& low_map)
-        : _graph(graph), _pred_map(pred_map), _tree_map(tree_map),
-          _order_map(order_map), _order_list(order_list),
-          _ancestor_map(ancestor_map), _low_map(low_map) {}
-
-      void reach(const Node& node) {
-        _order_map[node] = _order_list.size();
-        _low_map[node] = _order_list.size();
-        _ancestor_map[node] = _order_list.size();
-        _order_list.push_back(node);
-      }
-
-      void discover(const Arc& arc) {
-        Node target = _graph.target(arc);
-
-        _tree_map[arc] = true;
-        _pred_map[target] = arc;
-      }
-
-      void examine(const Arc& arc) {
-        Node source = _graph.source(arc);
-        Node target = _graph.target(arc);
-
-        if (_order_map[target] < _order_map[source] && !_tree_map[arc]) {
-          if (_low_map[source] > _order_map[target]) {
-            _low_map[source] = _order_map[target];
-          }
-          if (_ancestor_map[source] > _order_map[target]) {
-            _ancestor_map[source] = _order_map[target];
-          }
-        }
-      }
-
-      void backtrack(const Arc& arc) {
-        Node source = _graph.source(arc);
-        Node target = _graph.target(arc);
-
-        if (_low_map[source] > _low_map[target]) {
-          _low_map[source] = _low_map[target];
-        }
-      }
-
-      const Graph& _graph;
-      PredMap& _pred_map;
-      TreeMap& _tree_map;
-      OrderMap& _order_map;
-      OrderList& _order_list;
-      AncestorMap& _ancestor_map;
-      LowMap& _low_map;
-    };
-
-    template <typename Graph, bool embedding = true>
-    struct NodeDataNode {
-      int prev, next;
-      int visited;
-      typename Graph::Arc first;
-      bool inverted;
-    };
-
-    template <typename Graph>
-    struct NodeDataNode<Graph, false> {
-      int prev, next;
-      int visited;
-    };
-
-    template <typename Graph>
-    struct ChildListNode {
-      typedef typename Graph::Node Node;
-      Node first;
-      Node prev, next;
-    };
-
-    template <typename Graph>
-    struct ArcListNode {
-      typename Graph::Arc prev, next;
-    };
-
-    template <typename Graph>
-    class PlanarityChecking {
-    private:
-
-      TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-      const Graph& _graph;
-
-    private:
-
-      typedef typename Graph::template NodeMap<Arc> PredMap;
-
-      typedef typename Graph::template EdgeMap<bool> TreeMap;
-
-      typedef typename Graph::template NodeMap<int> OrderMap;
-      typedef std::vector<Node> OrderList;
-
-      typedef typename Graph::template NodeMap<int> LowMap;
-      typedef typename Graph::template NodeMap<int> AncestorMap;
-
-      typedef _planarity_bits::NodeDataNode<Graph> NodeDataNode;
-      typedef std::vector<NodeDataNode> NodeData;
-
-      typedef _planarity_bits::ChildListNode<Graph> ChildListNode;
-      typedef typename Graph::template NodeMap<ChildListNode> ChildLists;
-
-      typedef typename Graph::template NodeMap<std::list<int> > MergeRoots;
-
-      typedef typename Graph::template NodeMap<bool> EmbedArc;
-
-    public:
-
-      PlanarityChecking(const Graph& graph) : _graph(graph) {}
-
-      bool run() {
-        typedef _planarity_bits::PlanarityVisitor<Graph> Visitor;
-
-        PredMap pred_map(_graph, INVALID);
-        TreeMap tree_map(_graph, false);
-
-        OrderMap order_map(_graph, -1);
-        OrderList order_list;
-
-        AncestorMap ancestor_map(_graph, -1);
-        LowMap low_map(_graph, -1);
-
-        Visitor visitor(_graph, pred_map, tree_map,
-                        order_map, order_list, ancestor_map, low_map);
-        DfsVisit<Graph, Visitor> visit(_graph, visitor);
-        visit.run();
-
-        ChildLists child_lists(_graph);
-        createChildLists(tree_map, order_map, low_map, child_lists);
-
-        NodeData node_data(2 * order_list.size());
-
-        EmbedArc embed_arc(_graph, false);
-
-        MergeRoots merge_roots(_graph);
-
-        for (int i = order_list.size() - 1; i >= 0; --i) {
-
-          Node node = order_list[i];
-
-          Node source = node;
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && tree_map[e]) {
-              initFace(target, node_data, order_map, order_list);
-            }
-          }
-
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && !tree_map[e]) {
-              embed_arc[target] = true;
-              walkUp(target, source, i, pred_map, low_map,
-                     order_map, order_list, node_data, merge_roots);
-            }
-          }
-
-          for (typename MergeRoots::Value::iterator it =
-                 merge_roots[node].begin();
-               it != merge_roots[node].end(); ++it) {
-            int rn = *it;
-            walkDown(rn, i, node_data, order_list, child_lists,
-                     ancestor_map, low_map, embed_arc, merge_roots);
-          }
-          merge_roots[node].clear();
-
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && !tree_map[e]) {
-              if (embed_arc[target]) {
-                return false;
-              }
-            }
-          }
-        }
-
-        return true;
-      }
-
-    private:
-
-      void createChildLists(const TreeMap& tree_map, const OrderMap& order_map,
-                            const LowMap& low_map, ChildLists& child_lists) {
-
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          Node source = n;
-
-          std::vector<Node> targets;
-          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && tree_map[e]) {
-              targets.push_back(target);
-            }
-          }
-
-          if (targets.size() == 0) {
-            child_lists[source].first = INVALID;
-          } else if (targets.size() == 1) {
-            child_lists[source].first = targets[0];
-            child_lists[targets[0]].prev = INVALID;
-            child_lists[targets[0]].next = INVALID;
-          } else {
-            radixSort(targets.begin(), targets.end(), mapToFunctor(low_map));
-            for (int i = 1; i < int(targets.size()); ++i) {
-              child_lists[targets[i]].prev = targets[i - 1];
-              child_lists[targets[i - 1]].next = targets[i];
-            }
-            child_lists[targets.back()].next = INVALID;
-            child_lists[targets.front()].prev = INVALID;
-            child_lists[source].first = targets.front();
-          }
-        }
-      }
-
-      void walkUp(const Node& node, Node root, int rorder,
-                  const PredMap& pred_map, const LowMap& low_map,
-                  const OrderMap& order_map, const OrderList& order_list,
-                  NodeData& node_data, MergeRoots& merge_roots) {
-
-        int na, nb;
-        bool da, db;
-
-        na = nb = order_map[node];
-        da = true; db = false;
-
-        while (true) {
-
-          if (node_data[na].visited == rorder) break;
-          if (node_data[nb].visited == rorder) break;
-
-          node_data[na].visited = rorder;
-          node_data[nb].visited = rorder;
-
-          int rn = -1;
-
-          if (na >= int(order_list.size())) {
-            rn = na;
-          } else if (nb >= int(order_list.size())) {
-            rn = nb;
-          }
-
-          if (rn == -1) {
-            int nn;
-
-            nn = da ? node_data[na].prev : node_data[na].next;
-            da = node_data[nn].prev != na;
-            na = nn;
-
-            nn = db ? node_data[nb].prev : node_data[nb].next;
-            db = node_data[nn].prev != nb;
-            nb = nn;
-
-          } else {
-
-            Node rep = order_list[rn - order_list.size()];
-            Node parent = _graph.source(pred_map[rep]);
-
-            if (low_map[rep] < rorder) {
-              merge_roots[parent].push_back(rn);
-            } else {
-              merge_roots[parent].push_front(rn);
-            }
-
-            if (parent != root) {
-              na = nb = order_map[parent];
-              da = true; db = false;
-            } else {
-              break;
-            }
-          }
-        }
-      }
-
-      void walkDown(int rn, int rorder, NodeData& node_data,
-                    OrderList& order_list, ChildLists& child_lists,
-                    AncestorMap& ancestor_map, LowMap& low_map,
-                    EmbedArc& embed_arc, MergeRoots& merge_roots) {
-
-        std::vector<std::pair<int, bool> > merge_stack;
-
-        for (int di = 0; di < 2; ++di) {
-          bool rd = di == 0;
-          int pn = rn;
-          int n = rd ? node_data[rn].next : node_data[rn].prev;
-
-          while (n != rn) {
-
-            Node node = order_list[n];
-
-            if (embed_arc[node]) {
-
-              // Merging components on the critical path
-              while (!merge_stack.empty()) {
-
-                // Component root
-                int cn = merge_stack.back().first;
-                bool cd = merge_stack.back().second;
-                merge_stack.pop_back();
-
-                // Parent of component
-                int dn = merge_stack.back().first;
-                bool dd = merge_stack.back().second;
-                merge_stack.pop_back();
-
-                Node parent = order_list[dn];
-
-                // Erasing from merge_roots
-                merge_roots[parent].pop_front();
-
-                Node child = order_list[cn - order_list.size()];
-
-                // Erasing from child_lists
-                if (child_lists[child].prev != INVALID) {
-                  child_lists[child_lists[child].prev].next =
-                    child_lists[child].next;
-                } else {
-                  child_lists[parent].first = child_lists[child].next;
-                }
-
-                if (child_lists[child].next != INVALID) {
-                  child_lists[child_lists[child].next].prev =
-                    child_lists[child].prev;
-                }
-
-                // Merging external faces
-                {
-                  int en = cn;
-                  cn = cd ? node_data[cn].prev : node_data[cn].next;
-                  cd = node_data[cn].next == en;
-
-                }
-
-                if (cd) node_data[cn].next = dn; else node_data[cn].prev = dn;
-                if (dd) node_data[dn].prev = cn; else node_data[dn].next = cn;
-
-              }
-
-              bool d = pn == node_data[n].prev;
-
-              if (node_data[n].prev == node_data[n].next &&
-                  node_data[n].inverted) {
-                d = !d;
-              }
-
-              // Embedding arc into external face
-              if (rd) node_data[rn].next = n; else node_data[rn].prev = n;
-              if (d) node_data[n].prev = rn; else node_data[n].next = rn;
-              pn = rn;
-
-              embed_arc[order_list[n]] = false;
-            }
-
-            if (!merge_roots[node].empty()) {
-
-              bool d = pn == node_data[n].prev;
-
-              merge_stack.push_back(std::make_pair(n, d));
-
-              int rn = merge_roots[node].front();
-
-              int xn = node_data[rn].next;
-              Node xnode = order_list[xn];
-
-              int yn = node_data[rn].prev;
-              Node ynode = order_list[yn];
-
-              bool rd;
-              if (!external(xnode, rorder, child_lists,
-                            ancestor_map, low_map)) {
-                rd = true;
-              } else if (!external(ynode, rorder, child_lists,
-                                   ancestor_map, low_map)) {
-                rd = false;
-              } else if (pertinent(xnode, embed_arc, merge_roots)) {
-                rd = true;
-              } else {
-                rd = false;
-              }
-
-              merge_stack.push_back(std::make_pair(rn, rd));
-
-              pn = rn;
-              n = rd ? xn : yn;
-
-            } else if (!external(node, rorder, child_lists,
-                                 ancestor_map, low_map)) {
-              int nn = (node_data[n].next != pn ?
-                        node_data[n].next : node_data[n].prev);
-
-              bool nd = n == node_data[nn].prev;
-
-              if (nd) node_data[nn].prev = pn;
-              else node_data[nn].next = pn;
-
-              if (n == node_data[pn].prev) node_data[pn].prev = nn;
-              else node_data[pn].next = nn;
-
-              node_data[nn].inverted =
-                (node_data[nn].prev == node_data[nn].next && nd != rd);
-
-              n = nn;
-            }
-            else break;
-
-          }
-
-          if (!merge_stack.empty() || n == rn) {
-            break;
-          }
-        }
-      }
-
-      void initFace(const Node& node, NodeData& node_data,
-                    const OrderMap& order_map, const OrderList& order_list) {
-        int n = order_map[node];
-        int rn = n + order_list.size();
-
-        node_data[n].next = node_data[n].prev = rn;
-        node_data[rn].next = node_data[rn].prev = n;
-
-        node_data[n].visited = order_list.size();
-        node_data[rn].visited = order_list.size();
-
-      }
-
-      bool external(const Node& node, int rorder,
-                    ChildLists& child_lists, AncestorMap& ancestor_map,
-                    LowMap& low_map) {
-        Node child = child_lists[node].first;
-
-        if (child != INVALID) {
-          if (low_map[child] < rorder) return true;
-        }
-
-        if (ancestor_map[node] < rorder) return true;
-
-        return false;
-      }
-
-      bool pertinent(const Node& node, const EmbedArc& embed_arc,
-                     const MergeRoots& merge_roots) {
-        return !merge_roots[node].empty() || embed_arc[node];
-      }
-
-    };
-
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Planarity checking of an undirected simple graph
-  ///
-  /// This function implements the Boyer-Myrvold algorithm for
-  /// planarity checking of an undirected simple graph. It is a simplified
-  /// version of the PlanarEmbedding algorithm class because neither
-  /// the embedding nor the Kuratowski subdivisons are computed.
-  template <typename GR>
-  bool checkPlanarity(const GR& graph) {
-    _planarity_bits::PlanarityChecking<GR> pc(graph);
-    return pc.run();
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Planar embedding of an undirected simple graph
-  ///
-  /// This class implements the Boyer-Myrvold algorithm for planar
-  /// embedding of an undirected simple graph. The planar embedding is an
-  /// ordering of the outgoing edges of the nodes, which is a possible
-  /// configuration to draw the graph in the plane. If there is not
-  /// such ordering then the graph contains a K<sub>5</sub> (full graph
-  /// with 5 nodes) or a K<sub>3,3</sub> (complete bipartite graph on
-  /// 3 Red and 3 Blue nodes) subdivision.
-  ///
-  /// The current implementation calculates either an embedding or a
-  /// Kuratowski subdivision. The running time of the algorithm is O(n).
-  ///
-  /// \see PlanarDrawing, checkPlanarity()
-  template <typename Graph>
-  class PlanarEmbedding {
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    const Graph& _graph;
-    typename Graph::template ArcMap<Arc> _embedding;
-
-    typename Graph::template EdgeMap<bool> _kuratowski;
-
-  private:
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-
-    typedef typename Graph::template EdgeMap<bool> TreeMap;
-
-    typedef typename Graph::template NodeMap<int> OrderMap;
-    typedef std::vector<Node> OrderList;
-
-    typedef typename Graph::template NodeMap<int> LowMap;
-    typedef typename Graph::template NodeMap<int> AncestorMap;
-
-    typedef _planarity_bits::NodeDataNode<Graph> NodeDataNode;
-    typedef std::vector<NodeDataNode> NodeData;
-
-    typedef _planarity_bits::ChildListNode<Graph> ChildListNode;
-    typedef typename Graph::template NodeMap<ChildListNode> ChildLists;
-
-    typedef typename Graph::template NodeMap<std::list<int> > MergeRoots;
-
-    typedef typename Graph::template NodeMap<Arc> EmbedArc;
-
-    typedef _planarity_bits::ArcListNode<Graph> ArcListNode;
-    typedef typename Graph::template ArcMap<ArcListNode> ArcLists;
-
-    typedef typename Graph::template NodeMap<bool> FlipMap;
-
-    typedef typename Graph::template NodeMap<int> TypeMap;
-
-    enum IsolatorNodeType {
-      HIGHX = 6, LOWX = 7,
-      HIGHY = 8, LOWY = 9,
-      ROOT = 10, PERTINENT = 11,
-      INTERNAL = 12
-    };
-
-  public:
-
-    /// \brief The map type for storing the embedding
-    ///
-    /// The map type for storing the embedding.
-    /// \see embeddingMap()
-    typedef typename Graph::template ArcMap<Arc> EmbeddingMap;
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
-    PlanarEmbedding(const Graph& graph)
-      : _graph(graph), _embedding(_graph), _kuratowski(graph, false) {}
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// \param kuratowski If this parameter is set to \c false, then the
-    /// algorithm does not compute a Kuratowski subdivision.
-    /// \return \c true if the graph is planar.
-    bool run(bool kuratowski = true) {
-      typedef _planarity_bits::PlanarityVisitor<Graph> Visitor;
-
-      PredMap pred_map(_graph, INVALID);
-      TreeMap tree_map(_graph, false);
-
-      OrderMap order_map(_graph, -1);
-      OrderList order_list;
-
-      AncestorMap ancestor_map(_graph, -1);
-      LowMap low_map(_graph, -1);
-
-      Visitor visitor(_graph, pred_map, tree_map,
-                      order_map, order_list, ancestor_map, low_map);
-      DfsVisit<Graph, Visitor> visit(_graph, visitor);
-      visit.run();
-
-      ChildLists child_lists(_graph);
-      createChildLists(tree_map, order_map, low_map, child_lists);
-
-      NodeData node_data(2 * order_list.size());
-
-      EmbedArc embed_arc(_graph, INVALID);
-
-      MergeRoots merge_roots(_graph);
-
-      ArcLists arc_lists(_graph);
-
-      FlipMap flip_map(_graph, false);
-
-      for (int i = order_list.size() - 1; i >= 0; --i) {
-
-        Node node = order_list[i];
-
-        node_data[i].first = INVALID;
-
-        Node source = node;
-        for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && tree_map[e]) {
-            initFace(target, arc_lists, node_data,
-                     pred_map, order_map, order_list);
-          }
-        }
-
-        for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && !tree_map[e]) {
-            embed_arc[target] = e;
-            walkUp(target, source, i, pred_map, low_map,
-                   order_map, order_list, node_data, merge_roots);
-          }
-        }
-
-        for (typename MergeRoots::Value::iterator it =
-               merge_roots[node].begin(); it != merge_roots[node].end(); ++it) {
-          int rn = *it;
-          walkDown(rn, i, node_data, arc_lists, flip_map, order_list,
-                   child_lists, ancestor_map, low_map, embed_arc, merge_roots);
-        }
-        merge_roots[node].clear();
-
-        for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && !tree_map[e]) {
-            if (embed_arc[target] != INVALID) {
-              if (kuratowski) {
-                isolateKuratowski(e, node_data, arc_lists, flip_map,
-                                  order_map, order_list, pred_map, child_lists,
-                                  ancestor_map, low_map,
-                                  embed_arc, merge_roots);
-              }
-              return false;
-            }
-          }
-        }
-      }
-
-      for (int i = 0; i < int(order_list.size()); ++i) {
-
-        mergeRemainingFaces(order_list[i], node_data, order_list, order_map,
-                            child_lists, arc_lists);
-        storeEmbedding(order_list[i], node_data, order_map, pred_map,
-                       arc_lists, flip_map);
-      }
-
-      return true;
-    }
-
-    /// \brief Give back the successor of an arc
-    ///
-    /// This function gives back the successor of an arc. It makes
-    /// possible to query the cyclic order of the outgoing arcs from
-    /// a node.
-    Arc next(const Arc& arc) const {
-      return _embedding[arc];
-    }
-
-    /// \brief Give back the calculated embedding map
-    ///
-    /// This function gives back the calculated embedding map, which
-    /// contains the successor of each arc in the cyclic order of the
-    /// outgoing arcs of its source node.
-    const EmbeddingMap& embeddingMap() const {
-      return _embedding;
-    }
-
-    /// \brief Give back \c true if the given edge is in the Kuratowski
-    /// subdivision
-    ///
-    /// This function gives back \c true if the given edge is in the found
-    /// Kuratowski subdivision.
-    /// \pre The \c run() function must be called with \c true parameter
-    /// before using this function.
-    bool kuratowski(const Edge& edge) const {
-      return _kuratowski[edge];
-    }
-
-  private:
-
-    void createChildLists(const TreeMap& tree_map, const OrderMap& order_map,
-                          const LowMap& low_map, ChildLists& child_lists) {
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Node source = n;
-
-        std::vector<Node> targets;
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && tree_map[e]) {
-            targets.push_back(target);
-          }
-        }
-
-        if (targets.size() == 0) {
-          child_lists[source].first = INVALID;
-        } else if (targets.size() == 1) {
-          child_lists[source].first = targets[0];
-          child_lists[targets[0]].prev = INVALID;
-          child_lists[targets[0]].next = INVALID;
-        } else {
-          radixSort(targets.begin(), targets.end(), mapToFunctor(low_map));
-          for (int i = 1; i < int(targets.size()); ++i) {
-            child_lists[targets[i]].prev = targets[i - 1];
-            child_lists[targets[i - 1]].next = targets[i];
-          }
-          child_lists[targets.back()].next = INVALID;
-          child_lists[targets.front()].prev = INVALID;
-          child_lists[source].first = targets.front();
-        }
-      }
-    }
-
-    void walkUp(const Node& node, Node root, int rorder,
-                const PredMap& pred_map, const LowMap& low_map,
-                const OrderMap& order_map, const OrderList& order_list,
-                NodeData& node_data, MergeRoots& merge_roots) {
-
-      int na, nb;
-      bool da, db;
-
-      na = nb = order_map[node];
-      da = true; db = false;
-
-      while (true) {
-
-        if (node_data[na].visited == rorder) break;
-        if (node_data[nb].visited == rorder) break;
-
-        node_data[na].visited = rorder;
-        node_data[nb].visited = rorder;
-
-        int rn = -1;
-
-        if (na >= int(order_list.size())) {
-          rn = na;
-        } else if (nb >= int(order_list.size())) {
-          rn = nb;
-        }
-
-        if (rn == -1) {
-          int nn;
-
-          nn = da ? node_data[na].prev : node_data[na].next;
-          da = node_data[nn].prev != na;
-          na = nn;
-
-          nn = db ? node_data[nb].prev : node_data[nb].next;
-          db = node_data[nn].prev != nb;
-          nb = nn;
-
-        } else {
-
-          Node rep = order_list[rn - order_list.size()];
-          Node parent = _graph.source(pred_map[rep]);
-
-          if (low_map[rep] < rorder) {
-            merge_roots[parent].push_back(rn);
-          } else {
-            merge_roots[parent].push_front(rn);
-          }
-
-          if (parent != root) {
-            na = nb = order_map[parent];
-            da = true; db = false;
-          } else {
-            break;
-          }
-        }
-      }
-    }
-
-    void walkDown(int rn, int rorder, NodeData& node_data,
-                  ArcLists& arc_lists, FlipMap& flip_map,
-                  OrderList& order_list, ChildLists& child_lists,
-                  AncestorMap& ancestor_map, LowMap& low_map,
-                  EmbedArc& embed_arc, MergeRoots& merge_roots) {
-
-      std::vector<std::pair<int, bool> > merge_stack;
-
-      for (int di = 0; di < 2; ++di) {
-        bool rd = di == 0;
-        int pn = rn;
-        int n = rd ? node_data[rn].next : node_data[rn].prev;
-
-        while (n != rn) {
-
-          Node node = order_list[n];
-
-          if (embed_arc[node] != INVALID) {
-
-            // Merging components on the critical path
-            while (!merge_stack.empty()) {
-
-              // Component root
-              int cn = merge_stack.back().first;
-              bool cd = merge_stack.back().second;
-              merge_stack.pop_back();
-
-              // Parent of component
-              int dn = merge_stack.back().first;
-              bool dd = merge_stack.back().second;
-              merge_stack.pop_back();
-
-              Node parent = order_list[dn];
-
-              // Erasing from merge_roots
-              merge_roots[parent].pop_front();
-
-              Node child = order_list[cn - order_list.size()];
-
-              // Erasing from child_lists
-              if (child_lists[child].prev != INVALID) {
-                child_lists[child_lists[child].prev].next =
-                  child_lists[child].next;
-              } else {
-                child_lists[parent].first = child_lists[child].next;
-              }
-
-              if (child_lists[child].next != INVALID) {
-                child_lists[child_lists[child].next].prev =
-                  child_lists[child].prev;
-              }
-
-              // Merging arcs + flipping
-              Arc de = node_data[dn].first;
-              Arc ce = node_data[cn].first;
-
-              flip_map[order_list[cn - order_list.size()]] = cd != dd;
-              if (cd != dd) {
-                std::swap(arc_lists[ce].prev, arc_lists[ce].next);
-                ce = arc_lists[ce].prev;
-                std::swap(arc_lists[ce].prev, arc_lists[ce].next);
-              }
-
-              {
-                Arc dne = arc_lists[de].next;
-                Arc cne = arc_lists[ce].next;
-
-                arc_lists[de].next = cne;
-                arc_lists[ce].next = dne;
-
-                arc_lists[dne].prev = ce;
-                arc_lists[cne].prev = de;
-              }
-
-              if (dd) {
-                node_data[dn].first = ce;
-              }
-
-              // Merging external faces
-              {
-                int en = cn;
-                cn = cd ? node_data[cn].prev : node_data[cn].next;
-                cd = node_data[cn].next == en;
-
-                 if (node_data[cn].prev == node_data[cn].next &&
-                    node_data[cn].inverted) {
-                   cd = !cd;
-                 }
-              }
-
-              if (cd) node_data[cn].next = dn; else node_data[cn].prev = dn;
-              if (dd) node_data[dn].prev = cn; else node_data[dn].next = cn;
-
-            }
-
-            bool d = pn == node_data[n].prev;
-
-            if (node_data[n].prev == node_data[n].next &&
-                node_data[n].inverted) {
-              d = !d;
-            }
-
-            // Add new arc
-            {
-              Arc arc = embed_arc[node];
-              Arc re = node_data[rn].first;
-
-              arc_lists[arc_lists[re].next].prev = arc;
-              arc_lists[arc].next = arc_lists[re].next;
-              arc_lists[arc].prev = re;
-              arc_lists[re].next = arc;
-
-              if (!rd) {
-                node_data[rn].first = arc;
-              }
-
-              Arc rev = _graph.oppositeArc(arc);
-              Arc e = node_data[n].first;
-
-              arc_lists[arc_lists[e].next].prev = rev;
-              arc_lists[rev].next = arc_lists[e].next;
-              arc_lists[rev].prev = e;
-              arc_lists[e].next = rev;
-
-              if (d) {
-                node_data[n].first = rev;
-              }
-
-            }
-
-            // Embedding arc into external face
-            if (rd) node_data[rn].next = n; else node_data[rn].prev = n;
-            if (d) node_data[n].prev = rn; else node_data[n].next = rn;
-            pn = rn;
-
-            embed_arc[order_list[n]] = INVALID;
-          }
-
-          if (!merge_roots[node].empty()) {
-
-            bool d = pn == node_data[n].prev;
-            if (node_data[n].prev == node_data[n].next &&
-                node_data[n].inverted) {
-              d = !d;
-            }
-
-            merge_stack.push_back(std::make_pair(n, d));
-
-            int rn = merge_roots[node].front();
-
-            int xn = node_data[rn].next;
-            Node xnode = order_list[xn];
-
-            int yn = node_data[rn].prev;
-            Node ynode = order_list[yn];
-
-            bool rd;
-            if (!external(xnode, rorder, child_lists, ancestor_map, low_map)) {
-              rd = true;
-            } else if (!external(ynode, rorder, child_lists,
-                                 ancestor_map, low_map)) {
-              rd = false;
-            } else if (pertinent(xnode, embed_arc, merge_roots)) {
-              rd = true;
-            } else {
-              rd = false;
-            }
-
-            merge_stack.push_back(std::make_pair(rn, rd));
-
-            pn = rn;
-            n = rd ? xn : yn;
-
-          } else if (!external(node, rorder, child_lists,
-                               ancestor_map, low_map)) {
-            int nn = (node_data[n].next != pn ?
-                      node_data[n].next : node_data[n].prev);
-
-            bool nd = n == node_data[nn].prev;
-
-            if (nd) node_data[nn].prev = pn;
-            else node_data[nn].next = pn;
-
-            if (n == node_data[pn].prev) node_data[pn].prev = nn;
-            else node_data[pn].next = nn;
-
-            node_data[nn].inverted =
-              (node_data[nn].prev == node_data[nn].next && nd != rd);
-
-            n = nn;
-          }
-          else break;
-
-        }
-
-        if (!merge_stack.empty() || n == rn) {
-          break;
-        }
-      }
-    }
-
-    void initFace(const Node& node, ArcLists& arc_lists,
-                  NodeData& node_data, const PredMap& pred_map,
-                  const OrderMap& order_map, const OrderList& order_list) {
-      int n = order_map[node];
-      int rn = n + order_list.size();
-
-      node_data[n].next = node_data[n].prev = rn;
-      node_data[rn].next = node_data[rn].prev = n;
-
-      node_data[n].visited = order_list.size();
-      node_data[rn].visited = order_list.size();
-
-      node_data[n].inverted = false;
-      node_data[rn].inverted = false;
-
-      Arc arc = pred_map[node];
-      Arc rev = _graph.oppositeArc(arc);
-
-      node_data[rn].first = arc;
-      node_data[n].first = rev;
-
-      arc_lists[arc].prev = arc;
-      arc_lists[arc].next = arc;
-
-      arc_lists[rev].prev = rev;
-      arc_lists[rev].next = rev;
-
-    }
-
-    void mergeRemainingFaces(const Node& node, NodeData& node_data,
-                             OrderList& order_list, OrderMap& order_map,
-                             ChildLists& child_lists, ArcLists& arc_lists) {
-      while (child_lists[node].first != INVALID) {
-        int dd = order_map[node];
-        Node child = child_lists[node].first;
-        int cd = order_map[child] + order_list.size();
-        child_lists[node].first = child_lists[child].next;
-
-        Arc de = node_data[dd].first;
-        Arc ce = node_data[cd].first;
-
-        if (de != INVALID) {
-          Arc dne = arc_lists[de].next;
-          Arc cne = arc_lists[ce].next;
-
-          arc_lists[de].next = cne;
-          arc_lists[ce].next = dne;
-
-          arc_lists[dne].prev = ce;
-          arc_lists[cne].prev = de;
-        }
-
-        node_data[dd].first = ce;
-
-      }
-    }
-
-    void storeEmbedding(const Node& node, NodeData& node_data,
-                        OrderMap& order_map, PredMap& pred_map,
-                        ArcLists& arc_lists, FlipMap& flip_map) {
-
-      if (node_data[order_map[node]].first == INVALID) return;
-
-      if (pred_map[node] != INVALID) {
-        Node source = _graph.source(pred_map[node]);
-        flip_map[node] = flip_map[node] != flip_map[source];
-      }
-
-      Arc first = node_data[order_map[node]].first;
-      Arc prev = first;
-
-      Arc arc = flip_map[node] ?
-        arc_lists[prev].prev : arc_lists[prev].next;
-
-      _embedding[prev] = arc;
-
-      while (arc != first) {
-        Arc next = arc_lists[arc].prev == prev ?
-          arc_lists[arc].next : arc_lists[arc].prev;
-        prev = arc; arc = next;
-        _embedding[prev] = arc;
-      }
-    }
-
-
-    bool external(const Node& node, int rorder,
-                  ChildLists& child_lists, AncestorMap& ancestor_map,
-                  LowMap& low_map) {
-      Node child = child_lists[node].first;
-
-      if (child != INVALID) {
-        if (low_map[child] < rorder) return true;
-      }
-
-      if (ancestor_map[node] < rorder) return true;
-
-      return false;
-    }
-
-    bool pertinent(const Node& node, const EmbedArc& embed_arc,
-                   const MergeRoots& merge_roots) {
-      return !merge_roots[node].empty() || embed_arc[node] != INVALID;
-    }
-
-    int lowPoint(const Node& node, OrderMap& order_map, ChildLists& child_lists,
-                 AncestorMap& ancestor_map, LowMap& low_map) {
-      int low_point;
-
-      Node child = child_lists[node].first;
-
-      if (child != INVALID) {
-        low_point = low_map[child];
-      } else {
-        low_point = order_map[node];
-      }
-
-      if (low_point > ancestor_map[node]) {
-        low_point = ancestor_map[node];
-      }
-
-      return low_point;
-    }
-
-    int findComponentRoot(Node root, Node node, ChildLists& child_lists,
-                          OrderMap& order_map, OrderList& order_list) {
-
-      int order = order_map[root];
-      int norder = order_map[node];
-
-      Node child = child_lists[root].first;
-      while (child != INVALID) {
-        int corder = order_map[child];
-        if (corder > order && corder < norder) {
-          order = corder;
-        }
-        child = child_lists[child].next;
-      }
-      return order + order_list.size();
-    }
-
-    Node findPertinent(Node node, OrderMap& order_map, NodeData& node_data,
-                       EmbedArc& embed_arc, MergeRoots& merge_roots) {
-      Node wnode =_graph.target(node_data[order_map[node]].first);
-      while (!pertinent(wnode, embed_arc, merge_roots)) {
-        wnode = _graph.target(node_data[order_map[wnode]].first);
-      }
-      return wnode;
-    }
-
-
-    Node findExternal(Node node, int rorder, OrderMap& order_map,
-                      ChildLists& child_lists, AncestorMap& ancestor_map,
-                      LowMap& low_map, NodeData& node_data) {
-      Node wnode =_graph.target(node_data[order_map[node]].first);
-      while (!external(wnode, rorder, child_lists, ancestor_map, low_map)) {
-        wnode = _graph.target(node_data[order_map[wnode]].first);
-      }
-      return wnode;
-    }
-
-    void markCommonPath(Node node, int rorder, Node& wnode, Node& znode,
-                        OrderList& order_list, OrderMap& order_map,
-                        NodeData& node_data, ArcLists& arc_lists,
-                        EmbedArc& embed_arc, MergeRoots& merge_roots,
-                        ChildLists& child_lists, AncestorMap& ancestor_map,
-                        LowMap& low_map) {
-
-      Node cnode = node;
-      Node pred = INVALID;
-
-      while (true) {
-
-        bool pert = pertinent(cnode, embed_arc, merge_roots);
-        bool ext = external(cnode, rorder, child_lists, ancestor_map, low_map);
-
-        if (pert && ext) {
-          if (!merge_roots[cnode].empty()) {
-            int cn = merge_roots[cnode].back();
-
-            if (low_map[order_list[cn - order_list.size()]] < rorder) {
-              Arc arc = node_data[cn].first;
-              _kuratowski.set(arc, true);
-
-              pred = cnode;
-              cnode = _graph.target(arc);
-
-              continue;
-            }
-          }
-          wnode = znode = cnode;
-          return;
-
-        } else if (pert) {
-          wnode = cnode;
-
-          while (!external(cnode, rorder, child_lists, ancestor_map, low_map)) {
-            Arc arc = node_data[order_map[cnode]].first;
-
-            if (_graph.target(arc) == pred) {
-              arc = arc_lists[arc].next;
-            }
-            _kuratowski.set(arc, true);
-
-            Node next = _graph.target(arc);
-            pred = cnode; cnode = next;
-          }
-
-          znode = cnode;
-          return;
-
-        } else if (ext) {
-          znode = cnode;
-
-          while (!pertinent(cnode, embed_arc, merge_roots)) {
-            Arc arc = node_data[order_map[cnode]].first;
-
-            if (_graph.target(arc) == pred) {
-              arc = arc_lists[arc].next;
-            }
-            _kuratowski.set(arc, true);
-
-            Node next = _graph.target(arc);
-            pred = cnode; cnode = next;
-          }
-
-          wnode = cnode;
-          return;
-
-        } else {
-          Arc arc = node_data[order_map[cnode]].first;
-
-          if (_graph.target(arc) == pred) {
-            arc = arc_lists[arc].next;
-          }
-          _kuratowski.set(arc, true);
-
-          Node next = _graph.target(arc);
-          pred = cnode; cnode = next;
-        }
-
-      }
-
-    }
-
-    void orientComponent(Node root, int rn, OrderMap& order_map,
-                         PredMap& pred_map, NodeData& node_data,
-                         ArcLists& arc_lists, FlipMap& flip_map,
-                         TypeMap& type_map) {
-      node_data[order_map[root]].first = node_data[rn].first;
-      type_map[root] = 1;
-
-      std::vector<Node> st, qu;
-
-      st.push_back(root);
-      while (!st.empty()) {
-        Node node = st.back();
-        st.pop_back();
-        qu.push_back(node);
-
-        Arc arc = node_data[order_map[node]].first;
-
-        if (type_map[_graph.target(arc)] == 0) {
-          st.push_back(_graph.target(arc));
-          type_map[_graph.target(arc)] = 1;
-        }
-
-        Arc last = arc, pred = arc;
-        arc = arc_lists[arc].next;
-        while (arc != last) {
-
-          if (type_map[_graph.target(arc)] == 0) {
-            st.push_back(_graph.target(arc));
-            type_map[_graph.target(arc)] = 1;
-          }
-
-          Arc next = arc_lists[arc].next != pred ?
-            arc_lists[arc].next : arc_lists[arc].prev;
-          pred = arc; arc = next;
-        }
-
-      }
-
-      type_map[root] = 2;
-      flip_map[root] = false;
-
-      for (int i = 1; i < int(qu.size()); ++i) {
-
-        Node node = qu[i];
-
-        while (type_map[node] != 2) {
-          st.push_back(node);
-          type_map[node] = 2;
-          node = _graph.source(pred_map[node]);
-        }
-
-        bool flip = flip_map[node];
-
-        while (!st.empty()) {
-          node = st.back();
-          st.pop_back();
-
-          flip_map[node] = flip != flip_map[node];
-          flip = flip_map[node];
-
-          if (flip) {
-            Arc arc = node_data[order_map[node]].first;
-            std::swap(arc_lists[arc].prev, arc_lists[arc].next);
-            arc = arc_lists[arc].prev;
-            std::swap(arc_lists[arc].prev, arc_lists[arc].next);
-            node_data[order_map[node]].first = arc;
-          }
-        }
-      }
-
-      for (int i = 0; i < int(qu.size()); ++i) {
-
-        Arc arc = node_data[order_map[qu[i]]].first;
-        Arc last = arc, pred = arc;
-
-        arc = arc_lists[arc].next;
-        while (arc != last) {
-
-          if (arc_lists[arc].next == pred) {
-            std::swap(arc_lists[arc].next, arc_lists[arc].prev);
-          }
-          pred = arc; arc = arc_lists[arc].next;
-        }
-
-      }
-    }
-
-    void setFaceFlags(Node root, Node wnode, Node ynode, Node xnode,
-                      OrderMap& order_map, NodeData& node_data,
-                      TypeMap& type_map) {
-      Node node = _graph.target(node_data[order_map[root]].first);
-
-      while (node != ynode) {
-        type_map[node] = HIGHY;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-
-      while (node != wnode) {
-        type_map[node] = LOWY;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-
-      node = _graph.target(node_data[order_map[wnode]].first);
-
-      while (node != xnode) {
-        type_map[node] = LOWX;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-      type_map[node] = LOWX;
-
-      node = _graph.target(node_data[order_map[xnode]].first);
-      while (node != root) {
-        type_map[node] = HIGHX;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-
-      type_map[wnode] = PERTINENT;
-      type_map[root] = ROOT;
-    }
-
-    void findInternalPath(std::vector<Arc>& ipath,
-                          Node wnode, Node root, TypeMap& type_map,
-                          OrderMap& order_map, NodeData& node_data,
-                          ArcLists& arc_lists) {
-      std::vector<Arc> st;
-
-      Node node = wnode;
-
-      while (node != root) {
-        Arc arc = arc_lists[node_data[order_map[node]].first].next;
-        st.push_back(arc);
-        node = _graph.target(arc);
-      }
-
-      while (true) {
-        Arc arc = st.back();
-        if (type_map[_graph.target(arc)] == LOWX ||
-            type_map[_graph.target(arc)] == HIGHX) {
-          break;
-        }
-        if (type_map[_graph.target(arc)] == 2) {
-          type_map[_graph.target(arc)] = 3;
-
-          arc = arc_lists[_graph.oppositeArc(arc)].next;
-          st.push_back(arc);
-        } else {
-          st.pop_back();
-          arc = arc_lists[arc].next;
-
-          while (_graph.oppositeArc(arc) == st.back()) {
-            arc = st.back();
-            st.pop_back();
-            arc = arc_lists[arc].next;
-          }
-          st.push_back(arc);
-        }
-      }
-
-      for (int i = 0; i < int(st.size()); ++i) {
-        if (type_map[_graph.target(st[i])] != LOWY &&
-            type_map[_graph.target(st[i])] != HIGHY) {
-          for (; i < int(st.size()); ++i) {
-            ipath.push_back(st[i]);
-          }
-        }
-      }
-    }
-
-    void setInternalFlags(std::vector<Arc>& ipath, TypeMap& type_map) {
-      for (int i = 1; i < int(ipath.size()); ++i) {
-        type_map[_graph.source(ipath[i])] = INTERNAL;
-      }
-    }
-
-    void findPilePath(std::vector<Arc>& ppath,
-                      Node root, TypeMap& type_map, OrderMap& order_map,
-                      NodeData& node_data, ArcLists& arc_lists) {
-      std::vector<Arc> st;
-
-      st.push_back(_graph.oppositeArc(node_data[order_map[root]].first));
-      st.push_back(node_data[order_map[root]].first);
-
-      while (st.size() > 1) {
-        Arc arc = st.back();
-        if (type_map[_graph.target(arc)] == INTERNAL) {
-          break;
-        }
-        if (type_map[_graph.target(arc)] == 3) {
-          type_map[_graph.target(arc)] = 4;
-
-          arc = arc_lists[_graph.oppositeArc(arc)].next;
-          st.push_back(arc);
-        } else {
-          st.pop_back();
-          arc = arc_lists[arc].next;
-
-          while (!st.empty() && _graph.oppositeArc(arc) == st.back()) {
-            arc = st.back();
-            st.pop_back();
-            arc = arc_lists[arc].next;
-          }
-          st.push_back(arc);
-        }
-      }
-
-      for (int i = 1; i < int(st.size()); ++i) {
-        ppath.push_back(st[i]);
-      }
-    }
-
-
-    int markExternalPath(Node node, OrderMap& order_map,
-                         ChildLists& child_lists, PredMap& pred_map,
-                         AncestorMap& ancestor_map, LowMap& low_map) {
-      int lp = lowPoint(node, order_map, child_lists,
-                        ancestor_map, low_map);
-
-      if (ancestor_map[node] != lp) {
-        node = child_lists[node].first;
-        _kuratowski[pred_map[node]] = true;
-
-        while (ancestor_map[node] != lp) {
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node tnode = _graph.target(e);
-            if (order_map[tnode] > order_map[node] && low_map[tnode] == lp) {
-              node = tnode;
-              _kuratowski[e] = true;
-              break;
-            }
-          }
-        }
-      }
-
-      for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-        if (order_map[_graph.target(e)] == lp) {
-          _kuratowski[e] = true;
-          break;
-        }
-      }
-
-      return lp;
-    }
-
-    void markPertinentPath(Node node, OrderMap& order_map,
-                           NodeData& node_data, ArcLists& arc_lists,
-                           EmbedArc& embed_arc, MergeRoots& merge_roots) {
-      while (embed_arc[node] == INVALID) {
-        int n = merge_roots[node].front();
-        Arc arc = node_data[n].first;
-
-        _kuratowski.set(arc, true);
-
-        Node pred = node;
-        node = _graph.target(arc);
-        while (!pertinent(node, embed_arc, merge_roots)) {
-          arc = node_data[order_map[node]].first;
-          if (_graph.target(arc) == pred) {
-            arc = arc_lists[arc].next;
-          }
-          _kuratowski.set(arc, true);
-          pred = node;
-          node = _graph.target(arc);
-        }
-      }
-      _kuratowski.set(embed_arc[node], true);
-    }
-
-    void markPredPath(Node node, Node snode, PredMap& pred_map) {
-      while (node != snode) {
-        _kuratowski.set(pred_map[node], true);
-        node = _graph.source(pred_map[node]);
-      }
-    }
-
-    void markFacePath(Node ynode, Node xnode,
-                      OrderMap& order_map, NodeData& node_data) {
-      Arc arc = node_data[order_map[ynode]].first;
-      Node node = _graph.target(arc);
-      _kuratowski.set(arc, true);
-
-      while (node != xnode) {
-        arc = node_data[order_map[node]].first;
-        _kuratowski.set(arc, true);
-        node = _graph.target(arc);
-      }
-    }
-
-    void markInternalPath(std::vector<Arc>& path) {
-      for (int i = 0; i < int(path.size()); ++i) {
-        _kuratowski.set(path[i], true);
-      }
-    }
-
-    void markPilePath(std::vector<Arc>& path) {
-      for (int i = 0; i < int(path.size()); ++i) {
-        _kuratowski.set(path[i], true);
-      }
-    }
-
-    void isolateKuratowski(Arc arc, NodeData& node_data,
-                           ArcLists& arc_lists, FlipMap& flip_map,
-                           OrderMap& order_map, OrderList& order_list,
-                           PredMap& pred_map, ChildLists& child_lists,
-                           AncestorMap& ancestor_map, LowMap& low_map,
-                           EmbedArc& embed_arc, MergeRoots& merge_roots) {
-
-      Node root = _graph.source(arc);
-      Node enode = _graph.target(arc);
-
-      int rorder = order_map[root];
-
-      TypeMap type_map(_graph, 0);
-
-      int rn = findComponentRoot(root, enode, child_lists,
-                                 order_map, order_list);
-
-      Node xnode = order_list[node_data[rn].next];
-      Node ynode = order_list[node_data[rn].prev];
-
-      // Minor-A
-      {
-        while (!merge_roots[xnode].empty() || !merge_roots[ynode].empty()) {
-
-          if (!merge_roots[xnode].empty()) {
-            root = xnode;
-            rn = merge_roots[xnode].front();
-          } else {
-            root = ynode;
-            rn = merge_roots[ynode].front();
-          }
-
-          xnode = order_list[node_data[rn].next];
-          ynode = order_list[node_data[rn].prev];
-        }
-
-        if (root != _graph.source(arc)) {
-          orientComponent(root, rn, order_map, pred_map,
-                          node_data, arc_lists, flip_map, type_map);
-          markFacePath(root, root, order_map, node_data);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          Node lwnode = findPertinent(ynode, order_map, node_data,
-                                      embed_arc, merge_roots);
-
-          markPertinentPath(lwnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-
-          return;
-        }
-      }
-
-      orientComponent(root, rn, order_map, pred_map,
-                      node_data, arc_lists, flip_map, type_map);
-
-      Node wnode = findPertinent(ynode, order_map, node_data,
-                                 embed_arc, merge_roots);
-      setFaceFlags(root, wnode, ynode, xnode, order_map, node_data, type_map);
-
-
-      //Minor-B
-      if (!merge_roots[wnode].empty()) {
-        int cn = merge_roots[wnode].back();
-        Node rep = order_list[cn - order_list.size()];
-        if (low_map[rep] < rorder) {
-          markFacePath(root, root, order_map, node_data);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-
-          Node lwnode, lznode;
-          markCommonPath(wnode, rorder, lwnode, lznode, order_list,
-                         order_map, node_data, arc_lists, embed_arc,
-                         merge_roots, child_lists, ancestor_map, low_map);
-
-          markPertinentPath(lwnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-          int zlp = markExternalPath(lznode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-
-          int minlp = xlp < ylp ? xlp : ylp;
-          if (zlp < minlp) minlp = zlp;
-
-          int maxlp = xlp > ylp ? xlp : ylp;
-          if (zlp > maxlp) maxlp = zlp;
-
-          markPredPath(order_list[maxlp], order_list[minlp], pred_map);
-
-          return;
-        }
-      }
-
-      Node pxnode, pynode;
-      std::vector<Arc> ipath;
-      findInternalPath(ipath, wnode, root, type_map, order_map,
-                       node_data, arc_lists);
-      setInternalFlags(ipath, type_map);
-      pynode = _graph.source(ipath.front());
-      pxnode = _graph.target(ipath.back());
-
-      wnode = findPertinent(pynode, order_map, node_data,
-                            embed_arc, merge_roots);
-
-      // Minor-C
-      {
-        if (type_map[_graph.source(ipath.front())] == HIGHY) {
-          if (type_map[_graph.target(ipath.back())] == HIGHX) {
-            markFacePath(xnode, pxnode, order_map, node_data);
-          }
-          markFacePath(root, xnode, order_map, node_data);
-          markPertinentPath(wnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-          markInternalPath(ipath);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          return;
-        }
-
-        if (type_map[_graph.target(ipath.back())] == HIGHX) {
-          markFacePath(ynode, root, order_map, node_data);
-          markPertinentPath(wnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-          markInternalPath(ipath);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          return;
-        }
-      }
-
-      std::vector<Arc> ppath;
-      findPilePath(ppath, root, type_map, order_map, node_data, arc_lists);
-
-      // Minor-D
-      if (!ppath.empty()) {
-        markFacePath(ynode, xnode, order_map, node_data);
-        markPertinentPath(wnode, order_map, node_data, arc_lists,
-                          embed_arc, merge_roots);
-        markPilePath(ppath);
-        markInternalPath(ipath);
-        int xlp = markExternalPath(xnode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        int ylp = markExternalPath(ynode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-        return;
-      }
-
-      // Minor-E*
-      {
-
-        if (!external(wnode, rorder, child_lists, ancestor_map, low_map)) {
-          Node znode = findExternal(pynode, rorder, order_map,
-                                    child_lists, ancestor_map,
-                                    low_map, node_data);
-
-          if (type_map[znode] == LOWY) {
-            markFacePath(root, xnode, order_map, node_data);
-            markPertinentPath(wnode, order_map, node_data, arc_lists,
-                              embed_arc, merge_roots);
-            markInternalPath(ipath);
-            int xlp = markExternalPath(xnode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            int zlp = markExternalPath(znode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            markPredPath(root, order_list[xlp < zlp ? xlp : zlp], pred_map);
-          } else {
-            markFacePath(ynode, root, order_map, node_data);
-            markPertinentPath(wnode, order_map, node_data, arc_lists,
-                              embed_arc, merge_roots);
-            markInternalPath(ipath);
-            int ylp = markExternalPath(ynode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            int zlp = markExternalPath(znode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            markPredPath(root, order_list[ylp < zlp ? ylp : zlp], pred_map);
-          }
-          return;
-        }
-
-        int xlp = markExternalPath(xnode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        int ylp = markExternalPath(ynode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        int wlp = markExternalPath(wnode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-
-        if (wlp > xlp && wlp > ylp) {
-          markFacePath(root, root, order_map, node_data);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          return;
-        }
-
-        markInternalPath(ipath);
-        markPertinentPath(wnode, order_map, node_data, arc_lists,
-                          embed_arc, merge_roots);
-
-        if (xlp > ylp && xlp > wlp) {
-          markFacePath(root, pynode, order_map, node_data);
-          markFacePath(wnode, xnode, order_map, node_data);
-          markPredPath(root, order_list[ylp < wlp ? ylp : wlp], pred_map);
-          return;
-        }
-
-        if (ylp > xlp && ylp > wlp) {
-          markFacePath(pxnode, root, order_map, node_data);
-          markFacePath(ynode, wnode, order_map, node_data);
-          markPredPath(root, order_list[xlp < wlp ? xlp : wlp], pred_map);
-          return;
-        }
-
-        if (pynode != ynode) {
-          markFacePath(pxnode, wnode, order_map, node_data);
-
-          int minlp = xlp < ylp ? xlp : ylp;
-          if (wlp < minlp) minlp = wlp;
-
-          int maxlp = xlp > ylp ? xlp : ylp;
-          if (wlp > maxlp) maxlp = wlp;
-
-          markPredPath(order_list[maxlp], order_list[minlp], pred_map);
-          return;
-        }
-
-        if (pxnode != xnode) {
-          markFacePath(wnode, pynode, order_map, node_data);
-
-          int minlp = xlp < ylp ? xlp : ylp;
-          if (wlp < minlp) minlp = wlp;
-
-          int maxlp = xlp > ylp ? xlp : ylp;
-          if (wlp > maxlp) maxlp = wlp;
-
-          markPredPath(order_list[maxlp], order_list[minlp], pred_map);
-          return;
-        }
-
-        markFacePath(root, root, order_map, node_data);
-        int minlp = xlp < ylp ? xlp : ylp;
-        if (wlp < minlp) minlp = wlp;
-        markPredPath(root, order_list[minlp], pred_map);
-        return;
-      }
-
-    }
-
-  };
-
-  namespace _planarity_bits {
-
-    template <typename Graph, typename EmbeddingMap>
-    void makeConnected(Graph& graph, EmbeddingMap& embedding) {
-      DfsVisitor<Graph> null_visitor;
-      DfsVisit<Graph, DfsVisitor<Graph> > dfs(graph, null_visitor);
-      dfs.init();
-
-      typename Graph::Node u = INVALID;
-      for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-        if (!dfs.reached(n)) {
-          dfs.addSource(n);
-          dfs.start();
-          if (u == INVALID) {
-            u = n;
-          } else {
-            typename Graph::Node v = n;
-
-            typename Graph::Arc ue = typename Graph::OutArcIt(graph, u);
-            typename Graph::Arc ve = typename Graph::OutArcIt(graph, v);
-
-            typename Graph::Arc e = graph.direct(graph.addEdge(u, v), true);
-
-            if (ue != INVALID) {
-              embedding[e] = embedding[ue];
-              embedding[ue] = e;
-            } else {
-              embedding[e] = e;
-            }
-
-            if (ve != INVALID) {
-              embedding[graph.oppositeArc(e)] = embedding[ve];
-              embedding[ve] = graph.oppositeArc(e);
-            } else {
-              embedding[graph.oppositeArc(e)] = graph.oppositeArc(e);
-            }
-          }
-        }
-      }
-    }
-
-    template <typename Graph, typename EmbeddingMap>
-    void makeBiNodeConnected(Graph& graph, EmbeddingMap& embedding) {
-      typename Graph::template ArcMap<bool> processed(graph);
-
-      std::vector<typename Graph::Arc> arcs;
-      for (typename Graph::ArcIt e(graph); e != INVALID; ++e) {
-        arcs.push_back(e);
-      }
-
-      IterableBoolMap<Graph, typename Graph::Node> visited(graph, false);
-
-      for (int i = 0; i < int(arcs.size()); ++i) {
-        typename Graph::Arc pp = arcs[i];
-        if (processed[pp]) continue;
-
-        typename Graph::Arc e = embedding[graph.oppositeArc(pp)];
-        processed[e] = true;
-        visited.set(graph.source(e), true);
-
-        typename Graph::Arc p = e, l = e;
-        e = embedding[graph.oppositeArc(e)];
-
-        while (e != l) {
-          processed[e] = true;
-
-          if (visited[graph.source(e)]) {
-
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(graph.source(p),
-                                           graph.target(e)), true);
-            embedding[n] = p;
-            embedding[graph.oppositeArc(pp)] = n;
-
-            embedding[graph.oppositeArc(n)] =
-              embedding[graph.oppositeArc(e)];
-            embedding[graph.oppositeArc(e)] =
-              graph.oppositeArc(n);
-
-            p = n;
-            e = embedding[graph.oppositeArc(n)];
-          } else {
-            visited.set(graph.source(e), true);
-            pp = p;
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-          }
-        }
-        visited.setAll(false);
-      }
-    }
-
-
-    template <typename Graph, typename EmbeddingMap>
-    void makeMaxPlanar(Graph& graph, EmbeddingMap& embedding) {
-
-      typename Graph::template NodeMap<int> degree(graph);
-
-      for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-        degree[n] = countIncEdges(graph, n);
-      }
-
-      typename Graph::template ArcMap<bool> processed(graph);
-      IterableBoolMap<Graph, typename Graph::Node> visited(graph, false);
-
-      std::vector<typename Graph::Arc> arcs;
-      for (typename Graph::ArcIt e(graph); e != INVALID; ++e) {
-        arcs.push_back(e);
-      }
-
-      for (int i = 0; i < int(arcs.size()); ++i) {
-        typename Graph::Arc e = arcs[i];
-
-        if (processed[e]) continue;
-        processed[e] = true;
-
-        typename Graph::Arc mine = e;
-        int mind = degree[graph.source(e)];
-
-        int face_size = 1;
-
-        typename Graph::Arc l = e;
-        e = embedding[graph.oppositeArc(e)];
-        while (l != e) {
-          processed[e] = true;
-
-          ++face_size;
-
-          if (degree[graph.source(e)] < mind) {
-            mine = e;
-            mind = degree[graph.source(e)];
-          }
-
-          e = embedding[graph.oppositeArc(e)];
-        }
-
-        if (face_size < 4) {
-          continue;
-        }
-
-        typename Graph::Node s = graph.source(mine);
-        for (typename Graph::OutArcIt e(graph, s); e != INVALID; ++e) {
-          visited.set(graph.target(e), true);
-        }
-
-        typename Graph::Arc oppe = INVALID;
-
-        e = embedding[graph.oppositeArc(mine)];
-        e = embedding[graph.oppositeArc(e)];
-        while (graph.target(e) != s) {
-          if (visited[graph.source(e)]) {
-            oppe = e;
-            break;
-          }
-          e = embedding[graph.oppositeArc(e)];
-        }
-        visited.setAll(false);
-
-        if (oppe == INVALID) {
-
-          e = embedding[graph.oppositeArc(mine)];
-          typename Graph::Arc pn = mine, p = e;
-
-          e = embedding[graph.oppositeArc(e)];
-          while (graph.target(e) != s) {
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(s, graph.source(e)), true);
-
-            embedding[n] = pn;
-            embedding[graph.oppositeArc(n)] = e;
-            embedding[graph.oppositeArc(p)] = graph.oppositeArc(n);
-
-            pn = n;
-
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-          }
-
-          embedding[graph.oppositeArc(e)] = pn;
-
-        } else {
-
-          mine = embedding[graph.oppositeArc(mine)];
-          s = graph.source(mine);
-          oppe = embedding[graph.oppositeArc(oppe)];
-          typename Graph::Node t = graph.source(oppe);
-
-          typename Graph::Arc ce = graph.direct(graph.addEdge(s, t), true);
-          embedding[ce] = mine;
-          embedding[graph.oppositeArc(ce)] = oppe;
-
-          typename Graph::Arc pn = ce, p = oppe;
-          e = embedding[graph.oppositeArc(oppe)];
-          while (graph.target(e) != s) {
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(s, graph.source(e)), true);
-
-            embedding[n] = pn;
-            embedding[graph.oppositeArc(n)] = e;
-            embedding[graph.oppositeArc(p)] = graph.oppositeArc(n);
-
-            pn = n;
-
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-
-          }
-          embedding[graph.oppositeArc(e)] = pn;
-
-          pn = graph.oppositeArc(ce), p = mine;
-          e = embedding[graph.oppositeArc(mine)];
-          while (graph.target(e) != t) {
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(t, graph.source(e)), true);
-
-            embedding[n] = pn;
-            embedding[graph.oppositeArc(n)] = e;
-            embedding[graph.oppositeArc(p)] = graph.oppositeArc(n);
-
-            pn = n;
-
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-
-          }
-          embedding[graph.oppositeArc(e)] = pn;
-        }
-      }
-    }
-
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Schnyder's planar drawing algorithm
-  ///
-  /// The planar drawing algorithm calculates positions for the nodes
-  /// in the plane. These coordinates satisfy that if the edges are
-  /// represented with straight lines, then they will not intersect
-  /// each other.
-  ///
-  /// Scnyder's algorithm embeds the graph on an \c (n-2)x(n-2) size grid,
-  /// i.e. each node will be located in the \c [0..n-2]x[0..n-2] square.
-  /// The time complexity of the algorithm is O(n).
-  ///
-  /// \see PlanarEmbedding
-  template <typename Graph>
-  class PlanarDrawing {
-  public:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    /// \brief The point type for storing coordinates
-    typedef dim2::Point<int> Point;
-    /// \brief The map type for storing the coordinates of the nodes
-    typedef typename Graph::template NodeMap<Point> PointMap;
-
-
-    /// \brief Constructor
-    ///
-    /// Constructor
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
-    PlanarDrawing(const Graph& graph)
-      : _graph(graph), _point_map(graph) {}
-
-  private:
-
-    template <typename AuxGraph, typename AuxEmbeddingMap>
-    void drawing(const AuxGraph& graph,
-                 const AuxEmbeddingMap& next,
-                 PointMap& point_map) {
-      TEMPLATE_GRAPH_TYPEDEFS(AuxGraph);
-
-      typename AuxGraph::template ArcMap<Arc> prev(graph);
-
-      for (NodeIt n(graph); n != INVALID; ++n) {
-        Arc e = OutArcIt(graph, n);
-
-        Arc p = e, l = e;
-
-        e = next[e];
-        while (e != l) {
-          prev[e] = p;
-          p = e;
-          e = next[e];
-        }
-        prev[e] = p;
-      }
-
-      Node anode, bnode, cnode;
-
-      {
-        Arc e = ArcIt(graph);
-        anode = graph.source(e);
-        bnode = graph.target(e);
-        cnode = graph.target(next[graph.oppositeArc(e)]);
-      }
-
-      IterableBoolMap<AuxGraph, Node> proper(graph, false);
-      typename AuxGraph::template NodeMap<int> conn(graph, -1);
-
-      conn[anode] = conn[bnode] = -2;
-      {
-        for (OutArcIt e(graph, anode); e != INVALID; ++e) {
-          Node m = graph.target(e);
-          if (conn[m] == -1) {
-            conn[m] = 1;
-          }
-        }
-        conn[cnode] = 2;
-
-        for (OutArcIt e(graph, bnode); e != INVALID; ++e) {
-          Node m = graph.target(e);
-          if (conn[m] == -1) {
-            conn[m] = 1;
-          } else if (conn[m] != -2) {
-            conn[m] += 1;
-            Arc pe = graph.oppositeArc(e);
-            if (conn[graph.target(next[pe])] == -2) {
-              conn[m] -= 1;
-            }
-            if (conn[graph.target(prev[pe])] == -2) {
-              conn[m] -= 1;
-            }
-
-            proper.set(m, conn[m] == 1);
-          }
-        }
-      }
-
-
-      typename AuxGraph::template ArcMap<int> angle(graph, -1);
-
-      while (proper.trueNum() != 0) {
-        Node n = typename IterableBoolMap<AuxGraph, Node>::TrueIt(proper);
-        proper.set(n, false);
-        conn[n] = -2;
-
-        for (OutArcIt e(graph, n); e != INVALID; ++e) {
-          Node m = graph.target(e);
-          if (conn[m] == -1) {
-            conn[m] = 1;
-          } else if (conn[m] != -2) {
-            conn[m] += 1;
-            Arc pe = graph.oppositeArc(e);
-            if (conn[graph.target(next[pe])] == -2) {
-              conn[m] -= 1;
-            }
-            if (conn[graph.target(prev[pe])] == -2) {
-              conn[m] -= 1;
-            }
-
-            proper.set(m, conn[m] == 1);
-          }
-        }
-
-        {
-          Arc e = OutArcIt(graph, n);
-          Arc p = e, l = e;
-
-          e = next[e];
-          while (e != l) {
-
-            if (conn[graph.target(e)] == -2 && conn[graph.target(p)] == -2) {
-              Arc f = e;
-              angle[f] = 0;
-              f = next[graph.oppositeArc(f)];
-              angle[f] = 1;
-              f = next[graph.oppositeArc(f)];
-              angle[f] = 2;
-            }
-
-            p = e;
-            e = next[e];
-          }
-
-          if (conn[graph.target(e)] == -2 && conn[graph.target(p)] == -2) {
-            Arc f = e;
-            angle[f] = 0;
-            f = next[graph.oppositeArc(f)];
-            angle[f] = 1;
-            f = next[graph.oppositeArc(f)];
-            angle[f] = 2;
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<Node> apred(graph, INVALID);
-      typename AuxGraph::template NodeMap<Node> bpred(graph, INVALID);
-      typename AuxGraph::template NodeMap<Node> cpred(graph, INVALID);
-
-      typename AuxGraph::template NodeMap<int> apredid(graph, -1);
-      typename AuxGraph::template NodeMap<int> bpredid(graph, -1);
-      typename AuxGraph::template NodeMap<int> cpredid(graph, -1);
-
-      for (ArcIt e(graph); e != INVALID; ++e) {
-        if (angle[e] == angle[next[e]]) {
-          switch (angle[e]) {
-          case 2:
-            apred[graph.target(e)] = graph.source(e);
-            apredid[graph.target(e)] = graph.id(graph.source(e));
-            break;
-          case 1:
-            bpred[graph.target(e)] = graph.source(e);
-            bpredid[graph.target(e)] = graph.id(graph.source(e));
-            break;
-          case 0:
-            cpred[graph.target(e)] = graph.source(e);
-            cpredid[graph.target(e)] = graph.id(graph.source(e));
-            break;
-          }
-        }
-      }
-
-      cpred[anode] = INVALID;
-      cpred[bnode] = INVALID;
-
-      std::vector<Node> aorder, border, corder;
-
-      {
-        typename AuxGraph::template NodeMap<bool> processed(graph, false);
-        std::vector<Node> st;
-        for (NodeIt n(graph); n != INVALID; ++n) {
-          if (!processed[n] && n != bnode && n != cnode) {
-            st.push_back(n);
-            processed[n] = true;
-            Node m = apred[n];
-            while (m != INVALID && !processed[m]) {
-              st.push_back(m);
-              processed[m] = true;
-              m = apred[m];
-            }
-            while (!st.empty()) {
-              aorder.push_back(st.back());
-              st.pop_back();
-            }
-          }
-        }
-      }
-
-      {
-        typename AuxGraph::template NodeMap<bool> processed(graph, false);
-        std::vector<Node> st;
-        for (NodeIt n(graph); n != INVALID; ++n) {
-          if (!processed[n] && n != cnode && n != anode) {
-            st.push_back(n);
-            processed[n] = true;
-            Node m = bpred[n];
-            while (m != INVALID && !processed[m]) {
-              st.push_back(m);
-              processed[m] = true;
-              m = bpred[m];
-            }
-            while (!st.empty()) {
-              border.push_back(st.back());
-              st.pop_back();
-            }
-          }
-        }
-      }
-
-      {
-        typename AuxGraph::template NodeMap<bool> processed(graph, false);
-        std::vector<Node> st;
-        for (NodeIt n(graph); n != INVALID; ++n) {
-          if (!processed[n] && n != anode && n != bnode) {
-            st.push_back(n);
-            processed[n] = true;
-            Node m = cpred[n];
-            while (m != INVALID && !processed[m]) {
-              st.push_back(m);
-              processed[m] = true;
-              m = cpred[m];
-            }
-            while (!st.empty()) {
-              corder.push_back(st.back());
-              st.pop_back();
-            }
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<int> atree(graph, 0);
-      for (int i = aorder.size() - 1; i >= 0; --i) {
-        Node n = aorder[i];
-        atree[n] = 1;
-        for (OutArcIt e(graph, n); e != INVALID; ++e) {
-          if (apred[graph.target(e)] == n) {
-            atree[n] += atree[graph.target(e)];
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<int> btree(graph, 0);
-      for (int i = border.size() - 1; i >= 0; --i) {
-        Node n = border[i];
-        btree[n] = 1;
-        for (OutArcIt e(graph, n); e != INVALID; ++e) {
-          if (bpred[graph.target(e)] == n) {
-            btree[n] += btree[graph.target(e)];
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<int> apath(graph, 0);
-      apath[bnode] = apath[cnode] = 1;
-      typename AuxGraph::template NodeMap<int> apath_btree(graph, 0);
-      apath_btree[bnode] = btree[bnode];
-      for (int i = 1; i < int(aorder.size()); ++i) {
-        Node n = aorder[i];
-        apath[n] = apath[apred[n]] + 1;
-        apath_btree[n] = btree[n] + apath_btree[apred[n]];
-      }
-
-      typename AuxGraph::template NodeMap<int> bpath_atree(graph, 0);
-      bpath_atree[anode] = atree[anode];
-      for (int i = 1; i < int(border.size()); ++i) {
-        Node n = border[i];
-        bpath_atree[n] = atree[n] + bpath_atree[bpred[n]];
-      }
-
-      typename AuxGraph::template NodeMap<int> cpath(graph, 0);
-      cpath[anode] = cpath[bnode] = 1;
-      typename AuxGraph::template NodeMap<int> cpath_atree(graph, 0);
-      cpath_atree[anode] = atree[anode];
-      typename AuxGraph::template NodeMap<int> cpath_btree(graph, 0);
-      cpath_btree[bnode] = btree[bnode];
-      for (int i = 1; i < int(corder.size()); ++i) {
-        Node n = corder[i];
-        cpath[n] = cpath[cpred[n]] + 1;
-        cpath_atree[n] = atree[n] + cpath_atree[cpred[n]];
-        cpath_btree[n] = btree[n] + cpath_btree[cpred[n]];
-      }
-
-      typename AuxGraph::template NodeMap<int> third(graph);
-      for (NodeIt n(graph); n != INVALID; ++n) {
-        point_map[n].x =
-          bpath_atree[n] + cpath_atree[n] - atree[n] - cpath[n] + 1;
-        point_map[n].y =
-          cpath_btree[n] + apath_btree[n] - btree[n] - apath[n] + 1;
-      }
-
-    }
-
-  public:
-
-    /// \brief Calculate the node positions
-    ///
-    /// This function calculates the node positions on the plane.
-    /// \return \c true if the graph is planar.
-    bool run() {
-      PlanarEmbedding<Graph> pe(_graph);
-      if (!pe.run()) return false;
-
-      run(pe);
-      return true;
-    }
-
-    /// \brief Calculate the node positions according to a
-    /// combinatorical embedding
-    ///
-    /// This function calculates the node positions on the plane.
-    /// The given \c embedding map should contain a valid combinatorical
-    /// embedding, i.e. a valid cyclic order of the arcs.
-    /// It can be computed using PlanarEmbedding.
-    template <typename EmbeddingMap>
-    void run(const EmbeddingMap& embedding) {
-      typedef SmartEdgeSet<Graph> AuxGraph;
-
-      if (3 * countNodes(_graph) - 6 == countEdges(_graph)) {
-        drawing(_graph, embedding, _point_map);
-        return;
-      }
-
-      AuxGraph aux_graph(_graph);
-      typename AuxGraph::template ArcMap<typename AuxGraph::Arc>
-        aux_embedding(aux_graph);
-
-      {
-
-        typename Graph::template EdgeMap<typename AuxGraph::Edge>
-          ref(_graph);
-
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          ref[e] = aux_graph.addEdge(_graph.u(e), _graph.v(e));
-        }
-
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          Arc ee = embedding[_graph.direct(e, true)];
-          aux_embedding[aux_graph.direct(ref[e], true)] =
-            aux_graph.direct(ref[ee], _graph.direction(ee));
-          ee = embedding[_graph.direct(e, false)];
-          aux_embedding[aux_graph.direct(ref[e], false)] =
-            aux_graph.direct(ref[ee], _graph.direction(ee));
-        }
-      }
-      _planarity_bits::makeConnected(aux_graph, aux_embedding);
-      _planarity_bits::makeBiNodeConnected(aux_graph, aux_embedding);
-      _planarity_bits::makeMaxPlanar(aux_graph, aux_embedding);
-      drawing(aux_graph, aux_embedding, _point_map);
-    }
-
-    /// \brief The coordinate of the given node
-    ///
-    /// This function returns the coordinate of the given node.
-    Point operator[](const Node& node) const {
-      return _point_map[node];
-    }
-
-    /// \brief Return the grid embedding in a node map
-    ///
-    /// This function returns the grid embedding in a node map of
-    /// \c dim2::Point<int> coordinates.
-    const PointMap& coords() const {
-      return _point_map;
-    }
-
-  private:
-
-    const Graph& _graph;
-    PointMap _point_map;
-
-  };
-
-  namespace _planarity_bits {
-
-    template <typename ColorMap>
-    class KempeFilter {
-    public:
-      typedef typename ColorMap::Key Key;
-      typedef bool Value;
-
-      KempeFilter(const ColorMap& color_map,
-                  const typename ColorMap::Value& first,
-                  const typename ColorMap::Value& second)
-        : _color_map(color_map), _first(first), _second(second) {}
-
-      Value operator[](const Key& key) const {
-        return _color_map[key] == _first || _color_map[key] == _second;
-      }
-
-    private:
-      const ColorMap& _color_map;
-      typename ColorMap::Value _first, _second;
-    };
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Coloring planar graphs
-  ///
-  /// The graph coloring problem is the coloring of the graph nodes
-  /// so that there are no adjacent nodes with the same color. The
-  /// planar graphs can always be colored with four colors, which is
-  /// proved by Appel and Haken. Their proofs provide a quadratic
-  /// time algorithm for four coloring, but it could not be used to
-  /// implement an efficient algorithm. The five and six coloring can be
-  /// made in linear time, but in this class, the five coloring has
-  /// quadratic worst case time complexity. The two coloring (if
-  /// possible) is solvable with a graph search algorithm and it is
-  /// implemented in \ref bipartitePartitions() function in LEMON. To
-  /// decide whether a planar graph is three colorable is NP-complete.
-  ///
-  /// This class contains member functions for calculate colorings
-  /// with five and six colors. The six coloring algorithm is a simple
-  /// greedy coloring on the backward minimum outgoing order of nodes.
-  /// This order can be computed by selecting the node with least
-  /// outgoing arcs to unprocessed nodes in each phase. This order
-  /// guarantees that when a node is chosen for coloring it has at
-  /// most five already colored adjacents. The five coloring algorithm
-  /// use the same method, but if the greedy approach fails to color
-  /// with five colors, i.e. the node has five already different
-  /// colored neighbours, it swaps the colors in one of the connected
-  /// two colored sets with the Kempe recoloring method.
-  template <typename Graph>
-  class PlanarColoring {
-  public:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    /// \brief The map type for storing color indices
-    typedef typename Graph::template NodeMap<int> IndexMap;
-    /// \brief The map type for storing colors
-    ///
-    /// The map type for storing colors.
-    /// \see Palette, Color
-    typedef ComposeMap<Palette, IndexMap> ColorMap;
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
-    PlanarColoring(const Graph& graph)
-      : _graph(graph), _color_map(graph), _palette(0) {
-      _palette.add(Color(1,0,0));
-      _palette.add(Color(0,1,0));
-      _palette.add(Color(0,0,1));
-      _palette.add(Color(1,1,0));
-      _palette.add(Color(1,0,1));
-      _palette.add(Color(0,1,1));
-    }
-
-    /// \brief Return the node map of color indices
-    ///
-    /// This function returns the node map of color indices. The values are
-    /// in the range \c [0..4] or \c [0..5] according to the coloring method.
-    IndexMap colorIndexMap() const {
-      return _color_map;
-    }
-
-    /// \brief Return the node map of colors
-    ///
-    /// This function returns the node map of colors. The values are among
-    /// five or six distinct \ref lemon::Color "colors".
-    ColorMap colorMap() const {
-      return composeMap(_palette, _color_map);
-    }
-
-    /// \brief Return the color index of the node
-    ///
-    /// This function returns the color index of the given node. The value is
-    /// in the range \c [0..4] or \c [0..5] according to the coloring method.
-    int colorIndex(const Node& node) const {
-      return _color_map[node];
-    }
-
-    /// \brief Return the color of the node
-    ///
-    /// This function returns the color of the given node. The value is among
-    /// five or six distinct \ref lemon::Color "colors".
-    Color color(const Node& node) const {
-      return _palette[_color_map[node]];
-    }
-
-
-    /// \brief Calculate a coloring with at most six colors
-    ///
-    /// This function calculates a coloring with at most six colors. The time
-    /// complexity of this variant is linear in the size of the graph.
-    /// \return \c true if the algorithm could color the graph with six colors.
-    /// If the algorithm fails, then the graph is not planar.
-    /// \note This function can return \c true if the graph is not
-    /// planar, but it can be colored with at most six colors.
-    bool runSixColoring() {
-
-      typename Graph::template NodeMap<int> heap_index(_graph, -1);
-      BucketHeap<typename Graph::template NodeMap<int> > heap(heap_index);
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _color_map[n] = -2;
-        heap.push(n, countOutArcs(_graph, n));
-      }
-
-      std::vector<Node> order;
-
-      while (!heap.empty()) {
-        Node n = heap.top();
-        heap.pop();
-        _color_map[n] = -1;
-        order.push_back(n);
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] == -2) {
-            heap.decrease(t, heap[t] - 1);
-          }
-        }
-      }
-
-      for (int i = order.size() - 1; i >= 0; --i) {
-        std::vector<bool> forbidden(6, false);
-        for (OutArcIt e(_graph, order[i]); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] != -1) {
-            forbidden[_color_map[t]] = true;
-          }
-        }
-               for (int k = 0; k < 6; ++k) {
-          if (!forbidden[k]) {
-            _color_map[order[i]] = k;
-            break;
-          }
-        }
-        if (_color_map[order[i]] == -1) {
-          return false;
-        }
-      }
-      return true;
-    }
-
-  private:
-
-    bool recolor(const Node& u, const Node& v) {
-      int ucolor = _color_map[u];
-      int vcolor = _color_map[v];
-      typedef _planarity_bits::KempeFilter<IndexMap> KempeFilter;
-      KempeFilter filter(_color_map, ucolor, vcolor);
-
-      typedef FilterNodes<const Graph, const KempeFilter> KempeGraph;
-      KempeGraph kempe_graph(_graph, filter);
-
-      std::vector<Node> comp;
-      Bfs<KempeGraph> bfs(kempe_graph);
-      bfs.init();
-      bfs.addSource(u);
-      while (!bfs.emptyQueue()) {
-        Node n = bfs.nextNode();
-        if (n == v) return false;
-        comp.push_back(n);
-        bfs.processNextNode();
-      }
-
-      int scolor = ucolor + vcolor;
-      for (int i = 0; i < static_cast<int>(comp.size()); ++i) {
-        _color_map[comp[i]] = scolor - _color_map[comp[i]];
-      }
-
-      return true;
-    }
-
-    template <typename EmbeddingMap>
-    void kempeRecoloring(const Node& node, const EmbeddingMap& embedding) {
-      std::vector<Node> nodes;
-      nodes.reserve(4);
-
-      for (Arc e = OutArcIt(_graph, node); e != INVALID; e = embedding[e]) {
-        Node t = _graph.target(e);
-        if (_color_map[t] != -1) {
-          nodes.push_back(t);
-          if (nodes.size() == 4) break;
-        }
-      }
-
-      int color = _color_map[nodes[0]];
-      if (recolor(nodes[0], nodes[2])) {
-        _color_map[node] = color;
-      } else {
-        color = _color_map[nodes[1]];
-        recolor(nodes[1], nodes[3]);
-        _color_map[node] = color;
-      }
-    }
-
-  public:
-
-    /// \brief Calculate a coloring with at most five colors
-    ///
-    /// This function calculates a coloring with at most five
-    /// colors. The worst case time complexity of this variant is
-    /// quadratic in the size of the graph.
-    /// \param embedding This map should contain a valid combinatorical
-    /// embedding, i.e. a valid cyclic order of the arcs.
-    /// It can be computed using PlanarEmbedding.
-    template <typename EmbeddingMap>
-    void runFiveColoring(const EmbeddingMap& embedding) {
-
-      typename Graph::template NodeMap<int> heap_index(_graph, -1);
-      BucketHeap<typename Graph::template NodeMap<int> > heap(heap_index);
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _color_map[n] = -2;
-        heap.push(n, countOutArcs(_graph, n));
-      }
-
-      std::vector<Node> order;
-
-      while (!heap.empty()) {
-        Node n = heap.top();
-        heap.pop();
-        _color_map[n] = -1;
-        order.push_back(n);
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] == -2) {
-            heap.decrease(t, heap[t] - 1);
-          }
-        }
-      }
-
-      for (int i = order.size() - 1; i >= 0; --i) {
-        std::vector<bool> forbidden(5, false);
-        for (OutArcIt e(_graph, order[i]); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] != -1) {
-            forbidden[_color_map[t]] = true;
-          }
-        }
-        for (int k = 0; k < 5; ++k) {
-          if (!forbidden[k]) {
-            _color_map[order[i]] = k;
-            break;
-          }
-        }
-        if (_color_map[order[i]] == -1) {
-          kempeRecoloring(order[i], embedding);
-        }
-      }
-    }
-
-    /// \brief Calculate a coloring with at most five colors
-    ///
-    /// This function calculates a coloring with at most five
-    /// colors. The worst case time complexity of this variant is
-    /// quadratic in the size of the graph.
-    /// \return \c true if the graph is planar.
-    bool runFiveColoring() {
-      PlanarEmbedding<Graph> pe(_graph);
-      if (!pe.run()) return false;
-
-      runFiveColoring(pe.embeddingMap());
-      return true;
-    }
-
-  private:
-
-    const Graph& _graph;
-    IndexMap _color_map;
-    Palette _palette;
-  };
-
-}
-
-#endif
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 1254)
+++ lemon/preflow.h	(revision 1027)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -53,9 +53,5 @@
     /// The type of the map that stores the flow values.
     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-#ifdef DOXYGEN
-    typedef GR::ArcMap<Value> FlowMap;
-#else
     typedef typename Digraph::template ArcMap<Value> FlowMap;
-#endif
 
     /// \brief Instantiates a FlowMap.
@@ -72,10 +68,7 @@
     /// The elevator type used by Preflow algorithm.
     ///
-    /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
-    typedef lemon::Elevator<GR, GR::Node> Elevator;
-#else
-    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
-#endif
+    /// \sa Elevator
+    /// \sa LinkedElevator
+    typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
 
     /// \brief Instantiates an Elevator.
@@ -103,10 +96,9 @@
   /// This class provides an implementation of Goldberg-Tarjan's \e preflow
   /// \e push-relabel algorithm producing a \ref max_flow
-  /// "flow of maximum value" in a digraph \cite clrs01algorithms,
-  /// \cite amo93networkflows, \cite goldberg88newapproach.
+  /// "flow of maximum value" in a digraph.
   /// The preflow algorithms are the fastest known maximum
-  /// flow algorithms. The current implementation uses a mixture of the
+  /// flow algorithms. The current implementation use a mixture of the
   /// \e "highest label" and the \e "bound decrease" heuristics.
-  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{m})\f$.
+  /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
   ///
   /// The algorithm consists of two phases. After the first phase
@@ -114,15 +106,7 @@
   /// second phase constructs a feasible maximum flow on each arc.
   ///
-  /// \warning This implementation cannot handle infinite or very large
-  /// capacities (e.g. the maximum value of \c CAP::Value).
-  ///
   /// \tparam GR The type of the digraph the algorithm runs on.
   /// \tparam CAP The type of the capacity map. The default map
   /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref PreflowDefaultTraits
-  /// "PreflowDefaultTraits<GR, CAP>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename CAP, typename TR>
@@ -135,5 +119,5 @@
   public:
 
-    ///The \ref lemon::PreflowDefaultTraits "traits class" of the algorithm.
+    ///The \ref PreflowDefaultTraits "traits class" of the algorithm.
     typedef TR Traits;
     ///The type of the digraph the algorithm runs on.
@@ -274,5 +258,5 @@
     /// able to automatically created by the algorithm (i.e. the
     /// digraph and the maximum level should be passed to it).
-    /// However, an external elevator object could also be passed to the
+    /// However an external elevator object could also be passed to the
     /// algorithm with the \ref elevator(Elevator&) "elevator()" function
     /// before calling \ref run() or \ref init().
@@ -388,8 +372,7 @@
     }
 
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
     Preflow& tolerance(const Tolerance& tolerance) {
       _tolerance = tolerance;
@@ -399,6 +382,5 @@
     /// \brief Returns a const reference to the tolerance.
     ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
+    /// Returns a const reference to the tolerance.
     const Tolerance& tolerance() const {
       return _tolerance;
@@ -408,6 +390,6 @@
     /// The simplest way to execute the preflow algorithm is to use
     /// \ref run() or \ref runMinCut().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
+    /// If you need more control on the initial solution or the execution,
+    /// first you have to call one of the \ref init() functions, then
     /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
 
Index: lemon/quad_heap.h
===================================================================
--- lemon/quad_heap.h	(revision 929)
+++ 	(revision )
@@ -1,343 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_QUAD_HEAP_H
-#define LEMON_QUAD_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Fourary (quaternary) heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Fourary (quaternary) heap data structure.
-  ///
-  /// This class implements the \e Fourary (\e quaternary) \e heap
-  /// data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The fourary heap is a specialization of the \ref DHeap "D-ary heap"
-  /// for <tt>D=4</tt>. It is similar to the \ref BinHeap "binary heap",
-  /// but its nodes have at most four children, instead of two.
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-  ///
-  ///\sa BinHeap
-  ///\sa DHeap
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class QuadHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit QuadHeap(ItemIntMap &map) : _iim(map) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    QuadHeap(ItemIntMap &map, const Compare &comp)
-      : _iim(map), _comp(comp) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() { _data.clear(); }
-
-  private:
-    static int parent(int i) { return (i-1)/4; }
-    static int firstChild(int i) { return 4*i+1; }
-
-    bool less(const Pair &p1, const Pair &p2) const {
-      return _comp(p1.second, p2.second);
-    }
-
-    void bubbleUp(int hole, Pair p) {
-      int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
-        hole = par;
-        par = parent(hole);
-      }
-      move(p, hole);
-    }
-
-    void bubbleDown(int hole, Pair p, int length) {
-      if( length>1 ) {
-        int child = firstChild(hole);
-        while( child+3<length ) {
-          int min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( !less(_data[min], p) )
-            goto ok;
-          move(_data[min], hole);
-          hole = min;
-          child = firstChild(hole);
-        }
-        if ( child<length ) {
-          int min = child;
-          if( ++child<length && less(_data[child], _data[min]) ) min=child;
-          if( ++child<length && less(_data[child], _data[min]) ) min=child;
-          if( less(_data[min], p) ) {
-            move(_data[min], hole);
-            hole = min;
-          }
-        }
-      }
-    ok:
-      move(p, hole);
-    }
-
-    void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
-    }
-
-  public:
-    /// \brief Insert a pair of item and priority into the heap.
-    ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
-    /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
-    void push(const Pair &p) {
-      int n = _data.size();
-      _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param i The item to insert.
-    /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[0].first; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[0].second; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
-      if (n>0) bubbleDown(0, _data[n], n);
-      _data.pop_back();
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
-    void erase(const Item &i) {
-      int h = _iim[i];
-      int n = _data.size()-1;
-      _iim.set(_data[h].first, POST_HEAP);
-      if( h<n ) {
-        if( less(_data[parent(h)], _data[n]) )
-          bubbleDown(h, _data[n], n);
-        else
-          bubbleUp(h, _data[n]);
-      }
-      _data.pop_back();
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].second;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param i The item.
-    /// \param p The priority.
-    void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      if( idx < 0 )
-        push(i,p);
-      else if( _comp(p, _data[idx].second) )
-        bubbleUp(idx, Pair(i,p));
-      else
-        bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
-    void increase(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int s = _iim[i];
-      if (s>=0) s=0;
-      return State(s);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-        case POST_HEAP:
-        case PRE_HEAP:
-          if (state(i) == IN_HEAP) erase(i);
-          _iim[i] = st;
-          break;
-        case IN_HEAP:
-          break;
-      }
-    }
-
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
-    void replace(const Item& i, const Item& j) {
-      int idx = _iim[i];
-      _iim.set(i, _iim[j]);
-      _iim.set(j, idx);
-      _data[idx].first = j;
-    }
-
-  }; // class QuadHeap
-
-} // namespace lemon
-
-#endif // LEMON_FOURARY_HEAP_H
Index: lemon/radix_heap.h
===================================================================
--- lemon/radix_heap.h	(revision 758)
+++ lemon/radix_heap.h	(revision 730)
@@ -20,7 +20,7 @@
 #define LEMON_RADIX_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Radix heap implementation.
+///\brief Radix Heap implementation.
 
 #include <vector>
@@ -30,52 +30,54 @@
 
 
-  /// \ingroup heaps
+  /// \ingroup auxdata
   ///
-  /// \brief Radix heap data structure.
+  /// \brief A Radix Heap implementation.
   ///
-  /// This class implements the \e radix \e heap data structure.
-  /// It practically conforms to the \ref concepts::Heap "heap concept",
-  /// but it has some limitations due its special implementation.
-  /// The type of the priorities must be \c int and the priority of an
-  /// item cannot be decreased under the priority of the last removed item.
+  /// This class implements the \e radix \e heap data structure. A \e heap
+  /// is a data structure for storing items with specified values called \e
+  /// priorities in such a way that finding the item with minimum priority is
+  /// efficient. This heap type can store only items with \e int priority.
+  /// In a heap one can change the priority of an item, add or erase an
+  /// item, but the priority cannot be decreased under the last removed
+  /// item's priority.
   ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
+  /// \param IM A read and writable Item int map, used internally
+  /// to handle the cross references.
+  ///
+  /// \see BinHeap
+  /// \see Dijkstra
   template <typename IM>
   class RadixHeap {
 
   public:
-
-    /// Type of the item-int map.
+    typedef typename IM::Key Item;
+    typedef int Prio;
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
 
     /// \brief Exception thrown by RadixHeap.
     ///
-    /// This exception is thrown when an item is inserted into a
-    /// RadixHeap with a priority smaller than the last erased one.
+    /// This Exception is thrown when a smaller priority
+    /// is inserted into the \e RadixHeap then the last time erased.
     /// \see RadixHeap
-    class PriorityUnderflowError : public Exception {
+
+    class UnderFlowPriorityError : public Exception {
     public:
       virtual const char* what() const throw() {
-        return "lemon::RadixHeap::PriorityUnderflowError";
+        return "lemon::RadixHeap::UnderFlowPriorityError";
       }
     };
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    /// The ItemIntMap \e should be initialized in such way that it maps
+    /// PRE_HEAP (-1) to any element to be put in the heap...
     enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
+      IN_HEAP = 0,
+      PRE_HEAP = -1,
+      POST_HEAP = -2
     };
 
@@ -95,53 +97,50 @@
     };
 
-    std::vector<RadixItem> _data;
-    std::vector<RadixBox> _boxes;
+    std::vector<RadixItem> data;
+    std::vector<RadixBox> boxes;
 
     ItemIntMap &_iim;
 
+
   public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param minimum The initial minimum value of the heap.
-    /// \param capacity The initial capacity of the heap.
-    RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0)
-      : _iim(map)
-    {
-      _boxes.push_back(RadixBox(minimum, 1));
-      _boxes.push_back(RadixBox(minimum + 1, 1));
-      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    ///
+    /// \param map It should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    ///
+    /// \param minimal The initial minimal value of the heap.
+    /// \param capacity It determines the initial capacity of the heap.
+    RadixHeap(ItemIntMap &map, int minimal = 0, int capacity = 0)
+      : _iim(map) {
+      boxes.push_back(RadixBox(minimal, 1));
+      boxes.push_back(RadixBox(minimal + 1, 1));
+      while (lower(boxes.size() - 1, capacity + minimal - 1)) {
         extend();
       }
     }
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    /// \param minimum The minimum value of the heap.
-    /// \param capacity The capacity of the heap.
-    void clear(int minimum = 0, int capacity = 0) {
-      _data.clear(); _boxes.clear();
-      _boxes.push_back(RadixBox(minimum, 1));
-      _boxes.push_back(RadixBox(minimum + 1, 1));
-      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
+    int size() const { return data.size(); }
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
+    bool empty() const { return data.empty(); }
+
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference
+    /// map.  If you want to reuse a heap what is not surely empty you
+    /// should first clear the heap and after that you should set the
+    /// cross reference map for each item to \c PRE_HEAP.
+    void clear(int minimal = 0, int capacity = 0) {
+      data.clear(); boxes.clear();
+      boxes.push_back(RadixBox(minimal, 1));
+      boxes.push_back(RadixBox(minimal + 1, 1));
+      while (lower(boxes.size() - 1, capacity + minimal - 1)) {
         extend();
       }
@@ -151,56 +150,56 @@
 
     bool upper(int box, Prio pr) {
-      return pr < _boxes[box].min;
+      return pr < boxes[box].min;
     }
 
     bool lower(int box, Prio pr) {
-      return pr >= _boxes[box].min + _boxes[box].size;
-    }
-
-    // Remove item from the box list
+      return pr >= boxes[box].min + boxes[box].size;
+    }
+
+    /// \brief Remove item from the box list.
     void remove(int index) {
-      if (_data[index].prev >= 0) {
-        _data[_data[index].prev].next = _data[index].next;
+      if (data[index].prev >= 0) {
+        data[data[index].prev].next = data[index].next;
       } else {
-        _boxes[_data[index].box].first = _data[index].next;
-      }
-      if (_data[index].next >= 0) {
-        _data[_data[index].next].prev = _data[index].prev;
-      }
-    }
-
-    // Insert item into the box list
+        boxes[data[index].box].first = data[index].next;
+      }
+      if (data[index].next >= 0) {
+        data[data[index].next].prev = data[index].prev;
+      }
+    }
+
+    /// \brief Insert item into the box list.
     void insert(int box, int index) {
-      if (_boxes[box].first == -1) {
-        _boxes[box].first = index;
-        _data[index].next = _data[index].prev = -1;
+      if (boxes[box].first == -1) {
+        boxes[box].first = index;
+        data[index].next = data[index].prev = -1;
       } else {
-        _data[index].next = _boxes[box].first;
-        _data[_boxes[box].first].prev = index;
-        _data[index].prev = -1;
-        _boxes[box].first = index;
-      }
-      _data[index].box = box;
-    }
-
-    // Add a new box to the box list
+        data[index].next = boxes[box].first;
+        data[boxes[box].first].prev = index;
+        data[index].prev = -1;
+        boxes[box].first = index;
+      }
+      data[index].box = box;
+    }
+
+    /// \brief Add a new box to the box list.
     void extend() {
-      int min = _boxes.back().min + _boxes.back().size;
-      int bs = 2 * _boxes.back().size;
-      _boxes.push_back(RadixBox(min, bs));
-    }
-
-    // Move an item up into the proper box.
-    void bubbleUp(int index) {
-      if (!lower(_data[index].box, _data[index].prio)) return;
+      int min = boxes.back().min + boxes.back().size;
+      int bs = 2 * boxes.back().size;
+      boxes.push_back(RadixBox(min, bs));
+    }
+
+    /// \brief Move an item up into the proper box.
+    void bubble_up(int index) {
+      if (!lower(data[index].box, data[index].prio)) return;
       remove(index);
-      int box = findUp(_data[index].box, _data[index].prio);
+      int box = findUp(data[index].box, data[index].prio);
       insert(box, index);
     }
 
-    // Find up the proper box for the item with the given priority
+    /// \brief Find up the proper box for the item with the given prio.
     int findUp(int start, int pr) {
       while (lower(start, pr)) {
-        if (++start == int(_boxes.size())) {
+        if (++start == int(boxes.size())) {
           extend();
         }
@@ -209,37 +208,38 @@
     }
 
-    // Move an item down into the proper box
-    void bubbleDown(int index) {
-      if (!upper(_data[index].box, _data[index].prio)) return;
+    /// \brief Move an item down into the proper box.
+    void bubble_down(int index) {
+      if (!upper(data[index].box, data[index].prio)) return;
       remove(index);
-      int box = findDown(_data[index].box, _data[index].prio);
+      int box = findDown(data[index].box, data[index].prio);
       insert(box, index);
     }
 
-    // Find down the proper box for the item with the given priority
+    /// \brief Find up the proper box for the item with the given prio.
     int findDown(int start, int pr) {
       while (upper(start, pr)) {
-        if (--start < 0) throw PriorityUnderflowError();
+        if (--start < 0) throw UnderFlowPriorityError();
       }
       return start;
     }
 
-    // Find the first non-empty box
+    /// \brief Find the first not empty box.
     int findFirst() {
       int first = 0;
-      while (_boxes[first].first == -1) ++first;
+      while (boxes[first].first == -1) ++first;
       return first;
     }
 
-    // Gives back the minimum priority of the given box
+    /// \brief Gives back the minimal prio of the box.
     int minValue(int box) {
-      int min = _data[_boxes[box].first].prio;
-      for (int k = _boxes[box].first; k != -1; k = _data[k].next) {
-        if (_data[k].prio < min) min = _data[k].prio;
+      int min = data[boxes[box].first].prio;
+      for (int k = boxes[box].first; k != -1; k = data[k].next) {
+        if (data[k].prio < min) min = data[k].prio;
       }
       return min;
     }
 
-    // Rearrange the items of the heap and make the first box non-empty
+    /// \brief Rearrange the items of the heap and makes the
+    /// first box not empty.
     void moveDown() {
       int box = findFirst();
@@ -247,29 +247,29 @@
       int min = minValue(box);
       for (int i = 0; i <= box; ++i) {
-        _boxes[i].min = min;
-        min += _boxes[i].size;
-      }
-      int curr = _boxes[box].first, next;
+        boxes[i].min = min;
+        min += boxes[i].size;
+      }
+      int curr = boxes[box].first, next;
       while (curr != -1) {
-        next = _data[curr].next;
-        bubbleDown(curr);
+        next = data[curr].next;
+        bubble_down(curr);
         curr = next;
       }
     }
 
-    void relocateLast(int index) {
-      if (index != int(_data.size()) - 1) {
-        _data[index] = _data.back();
-        if (_data[index].prev != -1) {
-          _data[_data[index].prev].next = index;
+    void relocate_last(int index) {
+      if (index != int(data.size()) - 1) {
+        data[index] = data.back();
+        if (data[index].prev != -1) {
+          data[data[index].prev].next = index;
         } else {
-          _boxes[_data[index].box].first = index;
+          boxes[data[index].box].first = index;
         }
-        if (_data[index].next != -1) {
-          _data[_data[index].next].prev = index;
+        if (data[index].next != -1) {
+          data[data[index].next].prev = index;
         }
-        _iim[_data[index].item] = index;
-      }
-      _data.pop_back();
+        _iim[data[index].item] = index;
+      }
+      data.pop_back();
     }
 
@@ -278,84 +278,78 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void push(const Item &i, const Prio &p) {
-      int n = _data.size();
+      int n = data.size();
       _iim.set(i, n);
-      _data.push_back(RadixItem(i, p));
-      while (lower(_boxes.size() - 1, p)) {
+      data.push_back(RadixItem(i, p));
+      while (lower(boxes.size() - 1, p)) {
         extend();
       }
-      int box = findDown(_boxes.size() - 1, p);
+      int box = findDown(boxes.size() - 1, p);
       insert(box, n);
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].item;
-    }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+      return data[boxes[0].first].item;
+    }
+
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].prio;
+      return data[boxes[0].first].prio;
      }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
       moveDown();
-      int index = _boxes[0].first;
-      _iim[_data[index].item] = POST_HEAP;
+      int index = boxes[0].first;
+      _iim[data[index].item] = POST_HEAP;
       remove(index);
-      relocateLast(index);
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
+      relocate_last(index);
+    }
+
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap, if \c i was
+    /// already stored in the heap.
+    /// \param i The item to erase.
     void erase(const Item &i) {
       int index = _iim[i];
       _iim[i] = POST_HEAP;
       remove(index);
-      relocateLast(index);
+      relocate_last(index);
    }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \pre \c i must be in the heap.
+    /// \param i The item.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
-      return _data[idx].prio;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
+      return data[idx].prio;
+    }
+
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
+    /// It may throw an \e UnderFlowPriorityException.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be in the heap.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void set(const Item &i, const Prio &p) {
       int idx = _iim[i];
@@ -363,45 +357,46 @@
         push(i, p);
       }
-      else if( p >= _data[idx].prio ) {
-        _data[idx].prio = p;
-        bubbleUp(idx);
+      else if( p >= data[idx].prio ) {
+        data[idx].prio = p;
+        bubble_up(idx);
       } else {
-        _data[idx].prio = p;
-        bubbleDown(idx);
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+        data[idx].prio = p;
+        bubble_down(idx);
+      }
+    }
+
+
+    /// \brief Decreases the priority of \c i to \c p.
+    ///
+    /// This method decreases the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at least \c p, and
+    /// \c should be greater or equal to the last removed item's priority.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      _data[idx].prio = p;
-      bubbleDown(idx);
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+      data[idx].prio = p;
+      bubble_down(idx);
+    }
+
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at most \c p
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      _data[idx].prio = p;
-      bubbleUp(idx);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
+      data[idx].prio = p;
+      bubble_up(idx);
+    }
+
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
@@ -411,9 +406,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
Index: lemon/radix_sort.h
===================================================================
--- lemon/radix_sort.h	(revision 1210)
+++ lemon/radix_sort.h	(revision 606)
@@ -35,10 +35,4 @@
   namespace _radix_sort_bits {
 
-    template <typename Iterator>
-    bool unitRange(Iterator first, Iterator last) {
-      ++first;
-      return first == last;
-    }
-
     template <typename Value>
     struct Identity {
@@ -67,4 +61,7 @@
       std::iter_swap(first, last);
       ++first;
+      if (!(first < last)) {
+        return first;
+      }
       while (true) {
         while (!(functor(*first) & mask)) {
@@ -75,5 +72,5 @@
           --last;
         }
-        if (unitRange(last, first)) {
+        if (!(first < last)) {
           return first;
         }
@@ -101,4 +98,7 @@
       std::iter_swap(first, last);
       ++first;
+      if (!(first < last)) {
+        return first;
+      }
       while (true) {
         while (functor(*first) < 0) {
@@ -109,5 +109,5 @@
           --last;
         }
-        if (unitRange(last, first)) {
+        if (!(first < last)) {
           return first;
         }
@@ -120,5 +120,5 @@
     void radixIntroSort(Iterator first, Iterator last,
                         Functor functor, Value mask) {
-      while (mask != 0 && first != last && !unitRange(first, last)) {
+      while (mask != 0 && last - first > 1) {
         Iterator cut = radixSortPartition(first, last, functor, mask);
         mask >>= 1;
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 1193)
+++ lemon/smart_graph.h	(revision 664)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -33,5 +33,8 @@
 
   class SmartDigraph;
-
+  ///Base of SmartDigraph
+
+  ///Base of SmartDigraph
+  ///
   class SmartDigraphBase {
   protected:
@@ -185,26 +188,26 @@
   ///\brief A smart directed graph class.
   ///
-  ///\ref SmartDigraph is a simple and fast digraph implementation.
-  ///It is also quite memory efficient but at the price
-  ///that it does not support node and arc deletion
-  ///(except for the Snapshot feature).
+  ///This is a simple and fast digraph implementation.
+  ///It is also quite memory efficient, but at the price
+  ///that <b> it does support only limited (only stack-like)
+  ///node and arc deletions</b>.
+  ///It fully conforms to the \ref concepts::Digraph "Digraph concept".
   ///
-  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
-  ///and it also provides some additional functionalities.
-  ///Most of its member functions and nested classes are documented
-  ///only in the concept class.
-  ///
-  ///This class provides constant time counting for nodes and arcs.
-  ///
-  ///\sa concepts::Digraph
-  ///\sa SmartGraph
+  ///\sa concepts::Digraph.
   class SmartDigraph : public ExtendedSmartDigraphBase {
     typedef ExtendedSmartDigraphBase Parent;
 
   private:
-    /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
+
+    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+
+    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+    ///
     SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {};
-    /// \brief Assignment of a digraph to another one is \e not allowed.
-    /// Use DigraphCopy instead.
+    ///\brief Assignment of SmartDigraph to another one is \e not allowed.
+    ///Use DigraphCopy() instead.
+
+    ///Assignment of SmartDigraph to another one is \e not allowed.
+    ///Use DigraphCopy() instead.
     void operator=(const SmartDigraph &) {}
 
@@ -219,47 +222,77 @@
     ///Add a new node to the digraph.
 
-    ///This function adds a new node to the digraph.
-    ///\return The new node.
+    /// Add a new node to the digraph.
+    /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 
     ///Add a new arc to the digraph.
 
-    ///This function adds a new arc to the digraph with source node \c s
+    ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return The new arc.
-    Arc addArc(Node s, Node t) {
+    Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
     }
 
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
+
+    /// Using this it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveArc
+    void reserveNode(int n) { nodes.reserve(n); };
+
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
+
+    /// Using this it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveNode
+    void reserveArc(int m) { arcs.reserve(m); };
+
     /// \brief Node validity check
     ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the digraph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
     ///
     /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the digraph.
+    /// when new nodes are added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
     /// \brief Arc validity check
     ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the digraph.
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
     ///
     /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new arcs are added to the graph.
+    /// when new arcs are added to the graph.
     bool valid(Arc a) const { return Parent::valid(a); }
 
+    ///Clear the digraph.
+
+    ///Erase all the nodes and arcs from the digraph.
+    ///
+    void clear() {
+      Parent::clear();
+    }
+
     ///Split a node.
 
-    ///This function splits the given node. First, a new node is added
-    ///to the digraph, then the source of each outgoing arc of node \c n
-    ///is moved to this new node.
-    ///If the second parameter \c connect is \c true (this is the default
-    ///value), then a new arc from node \c n to the newly created node
-    ///is also added.
+    ///This function splits a node. First a new node is added to the digraph,
+    ///then the source of each outgoing arc of \c n is moved to this new node.
+    ///If \c connect is \c true (this is the default value), then a new arc
+    ///from \c n to the newly created node is also added.
     ///\return The newly created node.
     ///
-    ///\note All iterators remain valid.
-    ///
+    ///\note The <tt>Arc</tt>s
+    ///referencing a moved arc remain
+    ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s
+    ///may be invalidated.
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
@@ -276,32 +309,4 @@
     }
 
-    ///Clear the digraph.
-
-    ///This function erases all nodes and arcs from the digraph.
-    ///
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for arcs.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
-
   public:
 
@@ -328,21 +333,18 @@
   public:
 
-    ///Class to make a snapshot of the digraph and to restore it later.
-
-    ///Class to make a snapshot of the digraph and to restore it later.
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+
+    ///Class to make a snapshot of the digraph and to restrore to it later.
     ///
     ///The newly added nodes and arcs can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///arcs from a SmartDigraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state,
-    ///i.e. you cannot add the removed nodes and arcs again using
-    ///another Snapshot instance.
-    ///
-    ///\warning Node splitting cannot be restored.
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the digraph or no change.
+    ///restore() function.
+    ///\note After you restore a state, you cannot restore
+    ///a later state, in other word you cannot add again the arcs deleted
+    ///by restore() using another one Snapshot instance.
+    ///
+    ///\warning If you do not use correctly the snapshot that can cause
+    ///either broken program, invalid state of the digraph, valid but
+    ///not the restored digraph or no change. Because the runtime performance
+    ///the validity of the snapshot is not stored.
     class Snapshot
     {
@@ -356,11 +358,12 @@
 
       ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
+      ///To actually make a snapshot you must call save().
+      ///
       Snapshot() : _graph(0) {}
       ///Constructor that immediately makes a snapshot
 
-      ///This constructor immediately makes a snapshot of the given digraph.
-      ///
-      Snapshot(SmartDigraph &gr) : _graph(&gr) {
+      ///This constructor immediately makes a snapshot of the digraph.
+      ///\param graph The digraph we make a snapshot of.
+      Snapshot(SmartDigraph &graph) : _graph(&graph) {
         node_num=_graph->nodes.size();
         arc_num=_graph->arcs.size();
@@ -369,9 +372,12 @@
       ///Make a snapshot.
 
-      ///This function makes a snapshot of the given digraph.
-      ///It can be called more than once. In case of a repeated
+      ///Make a snapshot of the digraph.
+      ///
+      ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
-      void save(SmartDigraph &gr) {
-        _graph=&gr;
+      ///\param graph The digraph we make the snapshot of.
+      void save(SmartDigraph &graph)
+      {
+        _graph=&graph;
         node_num=_graph->nodes.size();
         arc_num=_graph->arcs.size();
@@ -380,6 +386,9 @@
       ///Undo the changes until a snapshot.
 
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartDigraph&).
+      ///Undo the changes until a snapshot created by save().
+      ///
+      ///\note After you restored a state, you cannot restore
+      ///a later state, in other word you cannot add again the arcs deleted
+      ///by restore().
       void restore()
       {
@@ -405,4 +414,6 @@
     std::vector<NodeT> nodes;
     std::vector<ArcT> arcs;
+
+    int first_free_arc;
 
   public:
@@ -498,5 +509,5 @@
     }
 
-    static void next(Node& node) {
+    void next(Node& node) const {
       --node._id;
     }
@@ -506,5 +517,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc._id;
     }
@@ -514,5 +525,5 @@
     }
 
-    static void next(Edge& arc) {
+    void next(Edge& arc) const {
       --arc._id;
     }
@@ -611,26 +622,27 @@
   /// \brief A smart undirected graph class.
   ///
-  /// \ref SmartGraph is a simple and fast graph implementation.
-  /// It is also quite memory efficient but at the price
-  /// that it does not support node and edge deletion
-  /// (except for the Snapshot feature).
+  /// This is a simple and fast graph implementation.
+  /// It is also quite memory efficient, but at the price
+  /// that <b> it does support only limited (only stack-like)
+  /// node and arc deletions</b>.
+  /// It fully conforms to the \ref concepts::Graph "Graph concept".
   ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept"
-  /// and it also provides some additional functionalities.
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \sa concepts::Graph
-  /// \sa SmartDigraph
+  /// \sa concepts::Graph.
   class SmartGraph : public ExtendedSmartGraphBase {
     typedef ExtendedSmartGraphBase Parent;
 
   private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
+
+    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
+
+    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
+    ///
     SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
+
+    ///\brief Assignment of SmartGraph to another one is \e not allowed.
+    ///Use GraphCopy() instead.
+
+    ///Assignment of SmartGraph to another one is \e not allowed.
+    ///Use GraphCopy() instead.
     void operator=(const SmartGraph &) {}
 
@@ -643,74 +655,53 @@
     SmartGraph() {}
 
-    /// \brief Add a new node to the graph.
-    ///
-    /// This function adds a new node to the graph.
+    ///Add a new node to the graph.
+
+    /// Add a new node to the graph.
     /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(Node u, Node v) {
-      return Parent::addEdge(u, v);
+    ///Add a new edge to the graph.
+
+    ///Add a new edge to the graph with node \c s
+    ///and \c t.
+    ///\return The new edge.
+    Edge addEdge(const Node& s, const Node& t) {
+      return Parent::addEdge(s, t);
     }
 
     /// \brief Node validity check
     ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
     ///
     /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the graph.
+    /// when new nodes are added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
+    /// \brief Arc validity check
+    ///
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning A removed arc (using Snapshot) could become valid again
+    /// when new edges are added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
+
     /// \brief Edge validity check
     ///
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
+    /// This function gives back true if the given edge is valid,
+    /// ie. it is a real edge of the graph.
     ///
     /// \warning A removed edge (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
+    /// when new edges are added to the graph.
     bool valid(Edge e) const { return Parent::valid(e); }
 
-    /// \brief Arc validity check
-    ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
     ///Clear the graph.
 
-    ///This function erases all nodes and arcs from the graph.
+    ///Erase all the nodes and edges from the graph.
     ///
     void clear() {
       Parent::clear();
     }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
   public:
@@ -752,20 +743,19 @@
   public:
 
-    ///Class to make a snapshot of the graph and to restore it later.
-
-    ///Class to make a snapshot of the graph and to restore it later.
-    ///
-    ///The newly added nodes and edges can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///edges from a SmartGraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state,
-    ///i.e. you cannot add the removed nodes and edges again using
-    ///another Snapshot instance.
-    ///
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the graph or no change.
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+    ///
+    ///The newly added nodes and arcs can be removed using the
+    ///restore() function.
+    ///
+    ///\note After you restore a state, you cannot restore
+    ///a later state, in other word you cannot add again the arcs deleted
+    ///by restore() using another one Snapshot instance.
+    ///
+    ///\warning If you do not use correctly the snapshot that can cause
+    ///either broken program, invalid state of the digraph, valid but
+    ///not the restored digraph or no change. Because the runtime performance
+    ///the validity of the snapshot is not stored.
     class Snapshot
     {
@@ -779,28 +769,34 @@
 
       ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
+      ///To actually make a snapshot you must call save().
+      ///
       Snapshot() : _graph(0) {}
       ///Constructor that immediately makes a snapshot
 
-      /// This constructor immediately makes a snapshot of the given graph.
+      ///This constructor immediately makes a snapshot of the digraph.
+      ///\param graph The digraph we make a snapshot of.
+      Snapshot(SmartGraph &graph) {
+        graph.saveSnapshot(*this);
+      }
+
+      ///Make a snapshot.
+
+      ///Make a snapshot of the graph.
       ///
-      Snapshot(SmartGraph &gr) {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Make a snapshot.
-
-      ///This function makes a snapshot of the given graph.
-      ///It can be called more than once. In case of a repeated
+      ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
-      void save(SmartGraph &gr)
+      ///\param graph The digraph we make the snapshot of.
+      void save(SmartGraph &graph)
       {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Undo the changes until the last snapshot.
-
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartGraph&).
+        graph.saveSnapshot(*this);
+      }
+
+      ///Undo the changes until a snapshot.
+
+      ///Undo the changes until a snapshot created by save().
+      ///
+      ///\note After you restored a state, you cannot restore
+      ///a later state, in other word you cannot add again the arcs deleted
+      ///by restore().
       void restore()
       {
@@ -810,533 +806,4 @@
   };
 
-  class SmartBpGraphBase {
-
-  protected:
-
-    struct NodeT {
-      int first_out;
-      int partition_next;
-      int partition_index;
-      bool red;
-    };
-
-    struct ArcT {
-      int target;
-      int next_out;
-    };
-
-    std::vector<NodeT> nodes;
-    std::vector<ArcT> arcs;
-
-    int first_red, first_blue;
-    int max_red, max_blue;
-
-  public:
-
-    typedef SmartBpGraphBase Graph;
-
-    class Node;
-    class Arc;
-    class Edge;
-
-    class Node {
-      friend class SmartBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Node(int id) { _id = id;}
-
-    public:
-      Node() {}
-      Node (Invalid) { _id = -1; }
-      bool operator==(const Node& node) const {return _id == node._id;}
-      bool operator!=(const Node& node) const {return _id != node._id;}
-      bool operator<(const Node& node) const {return _id < node._id;}
-    };
-
-    class RedNode : public Node {
-      friend class SmartBpGraphBase;
-    protected:
-
-      explicit RedNode(int pid) : Node(pid) {}
-
-    public:
-      RedNode() {}
-      RedNode(const RedNode& node) : Node(node) {}
-      RedNode(Invalid) : Node(INVALID){}
-    };
-
-    class BlueNode : public Node {
-      friend class SmartBpGraphBase;
-    protected:
-
-      explicit BlueNode(int pid) : Node(pid) {}
-
-    public:
-      BlueNode() {}
-      BlueNode(const BlueNode& node) : Node(node) {}
-      BlueNode(Invalid) : Node(INVALID){}
-    };
-
-    class Edge {
-      friend class SmartBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Edge(int id) { _id = id;}
-
-    public:
-      Edge() {}
-      Edge (Invalid) { _id = -1; }
-      bool operator==(const Edge& arc) const {return _id == arc._id;}
-      bool operator!=(const Edge& arc) const {return _id != arc._id;}
-      bool operator<(const Edge& arc) const {return _id < arc._id;}
-    };
-
-    class Arc {
-      friend class SmartBpGraphBase;
-    protected:
-
-      int _id;
-      explicit Arc(int id) { _id = id;}
-
-    public:
-      operator Edge() const {
-        return _id != -1 ? edgeFromId(_id / 2) : INVALID;
-      }
-
-      Arc() {}
-      Arc (Invalid) { _id = -1; }
-      bool operator==(const Arc& arc) const {return _id == arc._id;}
-      bool operator!=(const Arc& arc) const {return _id != arc._id;}
-      bool operator<(const Arc& arc) const {return _id < arc._id;}
-    };
-
-
-
-    SmartBpGraphBase()
-      : nodes(), arcs(), first_red(-1), first_blue(-1),
-        max_red(-1), max_blue(-1) {}
-
-    typedef True NodeNumTag;
-    typedef True EdgeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return nodes.size(); }
-    int redNum() const { return max_red + 1; }
-    int blueNum() const { return max_blue + 1; }
-    int edgeNum() const { return arcs.size() / 2; }
-    int arcNum() const { return arcs.size(); }
-
-    int maxNodeId() const { return nodes.size()-1; }
-    int maxRedId() const { return max_red; }
-    int maxBlueId() const { return max_blue; }
-    int maxEdgeId() const { return arcs.size() / 2 - 1; }
-    int maxArcId() const { return arcs.size()-1; }
-
-    bool red(Node n) const { return nodes[n._id].red; }
-    bool blue(Node n) const { return !nodes[n._id].red; }
-
-    static RedNode asRedNodeUnsafe(Node n) { return RedNode(n._id); }
-    static BlueNode asBlueNodeUnsafe(Node n) { return BlueNode(n._id); }
-
-    Node source(Arc a) const { return Node(arcs[a._id ^ 1].target); }
-    Node target(Arc a) const { return Node(arcs[a._id].target); }
-
-    RedNode redNode(Edge e) const {
-      return RedNode(arcs[2 * e._id].target);
-    }
-    BlueNode blueNode(Edge e) const {
-      return BlueNode(arcs[2 * e._id + 1].target);
-    }
-
-    static bool direction(Arc a) {
-      return (a._id & 1) == 1;
-    }
-
-    static Arc direct(Edge e, bool d) {
-      return Arc(e._id * 2 + (d ? 1 : 0));
-    }
-
-    void first(Node& node) const {
-      node._id = nodes.size() - 1;
-    }
-
-    static void next(Node& node) {
-      --node._id;
-    }
-
-    void first(RedNode& node) const {
-      node._id = first_red;
-    }
-
-    void next(RedNode& node) const {
-      node._id = nodes[node._id].partition_next;
-    }
-
-    void first(BlueNode& node) const {
-      node._id = first_blue;
-    }
-
-    void next(BlueNode& node) const {
-      node._id = nodes[node._id].partition_next;
-    }
-
-    void first(Arc& arc) const {
-      arc._id = arcs.size() - 1;
-    }
-
-    static void next(Arc& arc) {
-      --arc._id;
-    }
-
-    void first(Edge& arc) const {
-      arc._id = arcs.size() / 2 - 1;
-    }
-
-    static void next(Edge& arc) {
-      --arc._id;
-    }
-
-    void firstOut(Arc &arc, const Node& v) const {
-      arc._id = nodes[v._id].first_out;
-    }
-    void nextOut(Arc &arc) const {
-      arc._id = arcs[arc._id].next_out;
-    }
-
-    void firstIn(Arc &arc, const Node& v) const {
-      arc._id = ((nodes[v._id].first_out) ^ 1);
-      if (arc._id == -2) arc._id = -1;
-    }
-    void nextIn(Arc &arc) const {
-      arc._id = ((arcs[arc._id ^ 1].next_out) ^ 1);
-      if (arc._id == -2) arc._id = -1;
-    }
-
-    void firstInc(Edge &arc, bool& d, const Node& v) const {
-      int de = nodes[v._id].first_out;
-      if (de != -1) {
-        arc._id = de / 2;
-        d = ((de & 1) == 1);
-      } else {
-        arc._id = -1;
-        d = true;
-      }
-    }
-    void nextInc(Edge &arc, bool& d) const {
-      int de = (arcs[(arc._id * 2) | (d ? 1 : 0)].next_out);
-      if (de != -1) {
-        arc._id = de / 2;
-        d = ((de & 1) == 1);
-      } else {
-        arc._id = -1;
-        d = true;
-      }
-    }
-
-    static int id(Node v) { return v._id; }
-    int id(RedNode v) const { return nodes[v._id].partition_index; }
-    int id(BlueNode v) const { return nodes[v._id].partition_index; }
-    static int id(Arc e) { return e._id; }
-    static int id(Edge e) { return e._id; }
-
-    static Node nodeFromId(int id) { return Node(id);}
-    static Arc arcFromId(int id) { return Arc(id);}
-    static Edge edgeFromId(int id) { return Edge(id);}
-
-    bool valid(Node n) const {
-      return n._id >= 0 && n._id < static_cast<int>(nodes.size());
-    }
-    bool valid(Arc a) const {
-      return a._id >= 0 && a._id < static_cast<int>(arcs.size());
-    }
-    bool valid(Edge e) const {
-      return e._id >= 0 && 2 * e._id < static_cast<int>(arcs.size());
-    }
-
-    RedNode addRedNode() {
-      int n = nodes.size();
-      nodes.push_back(NodeT());
-      nodes[n].first_out = -1;
-      nodes[n].red = true;
-      nodes[n].partition_index = ++max_red;
-      nodes[n].partition_next = first_red;
-      first_red = n;
-
-      return RedNode(n);
-    }
-
-    BlueNode addBlueNode() {
-      int n = nodes.size();
-      nodes.push_back(NodeT());
-      nodes[n].first_out = -1;
-      nodes[n].red = false;
-      nodes[n].partition_index = ++max_blue;
-      nodes[n].partition_next = first_blue;
-      first_blue = n;
-
-      return BlueNode(n);
-    }
-
-    Edge addEdge(RedNode u, BlueNode v) {
-      int n = arcs.size();
-      arcs.push_back(ArcT());
-      arcs.push_back(ArcT());
-
-      arcs[n].target = u._id;
-      arcs[n | 1].target = v._id;
-
-      arcs[n].next_out = nodes[v._id].first_out;
-      nodes[v._id].first_out = n;
-
-      arcs[n | 1].next_out = nodes[u._id].first_out;
-      nodes[u._id].first_out = (n | 1);
-
-      return Edge(n / 2);
-    }
-
-    void clear() {
-      arcs.clear();
-      nodes.clear();
-      first_red = -1;
-      first_blue = -1;
-      max_blue = -1;
-      max_red = -1;
-    }
-
-  };
-
-  typedef BpGraphExtender<SmartBpGraphBase> ExtendedSmartBpGraphBase;
-
-  /// \ingroup graphs
-  ///
-  /// \brief A smart undirected bipartite graph class.
-  ///
-  /// \ref SmartBpGraph is a simple and fast bipartite graph implementation.
-  /// It is also quite memory efficient but at the price
-  /// that it does not support node and edge deletion
-  /// (except for the Snapshot feature).
-  ///
-  /// This type fully conforms to the \ref concepts::BpGraph "BpGraph concept"
-  /// and it also provides some additional functionalities.
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \sa concepts::BpGraph
-  /// \sa SmartGraph
-  class SmartBpGraph : public ExtendedSmartBpGraphBase {
-    typedef ExtendedSmartBpGraphBase Parent;
-
-  private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
-    SmartBpGraph(const SmartBpGraph &) : ExtendedSmartBpGraphBase() {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
-    void operator=(const SmartBpGraph &) {}
-
-  public:
-
-    /// Constructor
-
-    /// Constructor.
-    ///
-    SmartBpGraph() {}
-
-    /// \brief Add a new red node to the graph.
-    ///
-    /// This function adds a red new node to the graph.
-    /// \return The new node.
-    RedNode addRedNode() { return Parent::addRedNode(); }
-
-    /// \brief Add a new blue node to the graph.
-    ///
-    /// This function adds a blue new node to the graph.
-    /// \return The new node.
-    BlueNode addBlueNode() { return Parent::addBlueNode(); }
-
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(RedNode u, BlueNode v) {
-      return Parent::addEdge(u, v);
-    }
-    Edge addEdge(BlueNode v, RedNode u) {
-      return Parent::addEdge(u, v);
-    }
-
-    /// \brief Node validity check
-    ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the graph.
-    bool valid(Node n) const { return Parent::valid(n); }
-
-    /// \brief Edge validity check
-    ///
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
-    bool valid(Edge e) const { return Parent::valid(e); }
-
-    /// \brief Arc validity check
-    ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
-
-  public:
-
-    class Snapshot;
-
-  protected:
-
-    void saveSnapshot(Snapshot &s)
-    {
-      s._graph = this;
-      s.node_num = nodes.size();
-      s.arc_num = arcs.size();
-    }
-
-    void restoreSnapshot(const Snapshot &s)
-    {
-      while(s.arc_num<arcs.size()) {
-        int n=arcs.size()-1;
-        Edge arc=edgeFromId(n/2);
-        Parent::notifier(Edge()).erase(arc);
-        std::vector<Arc> dir;
-        dir.push_back(arcFromId(n));
-        dir.push_back(arcFromId(n-1));
-        Parent::notifier(Arc()).erase(dir);
-        nodes[arcs[n-1].target].first_out=arcs[n].next_out;
-        nodes[arcs[n].target].first_out=arcs[n-1].next_out;
-        arcs.pop_back();
-        arcs.pop_back();
-      }
-      while(s.node_num<nodes.size()) {
-        int n=nodes.size()-1;
-        Node node = nodeFromId(n);
-        if (Parent::red(node)) {
-          first_red = nodes[n].partition_next;
-          if (first_red != -1) {
-            max_red = nodes[first_red].partition_index;
-          } else {
-            max_red = -1;
-          }
-          Parent::notifier(RedNode()).erase(asRedNodeUnsafe(node));          
-        } else {
-          first_blue = nodes[n].partition_next;
-          if (first_blue != -1) {
-            max_blue = nodes[first_blue].partition_index;
-          } else {
-            max_blue = -1;
-          }
-          Parent::notifier(BlueNode()).erase(asBlueNodeUnsafe(node));
-        }
-        Parent::notifier(Node()).erase(node);
-        nodes.pop_back();
-      }
-    }
-
-  public:
-
-    ///Class to make a snapshot of the graph and to restore it later.
-
-    ///Class to make a snapshot of the graph and to restore it later.
-    ///
-    ///The newly added nodes and edges can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///edges from a SmartBpGraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state,
-    ///i.e. you cannot add the removed nodes and edges again using
-    ///another Snapshot instance.
-    ///
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the graph or no change.
-    class Snapshot
-    {
-      SmartBpGraph *_graph;
-    protected:
-      friend class SmartBpGraph;
-      unsigned int node_num;
-      unsigned int arc_num;
-    public:
-      ///Default constructor.
-
-      ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
-      Snapshot() : _graph(0) {}
-      ///Constructor that immediately makes a snapshot
-
-      /// This constructor immediately makes a snapshot of the given graph.
-      ///
-      Snapshot(SmartBpGraph &gr) {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Make a snapshot.
-
-      ///This function makes a snapshot of the given graph.
-      ///It can be called more than once. In case of a repeated
-      ///call, the previous snapshot gets lost.
-      void save(SmartBpGraph &gr)
-      {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Undo the changes until the last snapshot.
-
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartBpGraph&).
-      void restore()
-      {
-        _graph->restoreSnapshot(*this);
-      }
-    };
-  };
-
 } //namespace lemon
 
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 956)
+++ lemon/soplex.cc	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -92,17 +92,4 @@
   }
 
-  int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-    soplex::DSVector v;
-    for (ExprIterator it = b; it != e; ++it) {
-      v.add(it->first, it->second);
-    }
-    soplex::LPRow r(l, v, u);
-    soplex->addRow(r);
-
-    _row_names.push_back(std::string());
-
-    return soplex->nRows() - 1;
-  }
-
 
   void SoplexLp::_eraseCol(int i) {
@@ -288,5 +275,5 @@
 
     _clear_temporals();
-
+    
     _applyMessageLevel();
 
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 956)
+++ lemon/soplex.h	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -85,5 +85,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
Index: lemon/static_graph.h
===================================================================
--- lemon/static_graph.h	(revision 956)
+++ 	(revision )
@@ -1,476 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_STATIC_GRAPH_H
-#define LEMON_STATIC_GRAPH_H
-
-///\ingroup graphs
-///\file
-///\brief StaticDigraph class.
-
-#include <lemon/core.h>
-#include <lemon/bits/graph_extender.h>
-
-namespace lemon {
-
-  class StaticDigraphBase {
-  public:
-
-    StaticDigraphBase()
-      : built(false), node_num(0), arc_num(0),
-        node_first_out(NULL), node_first_in(NULL),
-        arc_source(NULL), arc_target(NULL),
-        arc_next_in(NULL), arc_next_out(NULL) {}
-
-    ~StaticDigraphBase() {
-      if (built) {
-        delete[] node_first_out;
-        delete[] node_first_in;
-        delete[] arc_source;
-        delete[] arc_target;
-        delete[] arc_next_out;
-        delete[] arc_next_in;
-      }
-    }
-
-    class Node {
-      friend class StaticDigraphBase;
-    protected:
-      int id;
-      Node(int _id) : id(_id) {}
-    public:
-      Node() {}
-      Node (Invalid) : id(-1) {}
-      bool operator==(const Node& node) const { return id == node.id; }
-      bool operator!=(const Node& node) const { return id != node.id; }
-      bool operator<(const Node& node) const { return id < node.id; }
-    };
-
-    class Arc {
-      friend class StaticDigraphBase;
-    protected:
-      int id;
-      Arc(int _id) : id(_id) {}
-    public:
-      Arc() { }
-      Arc (Invalid) : id(-1) {}
-      bool operator==(const Arc& arc) const { return id == arc.id; }
-      bool operator!=(const Arc& arc) const { return id != arc.id; }
-      bool operator<(const Arc& arc) const { return id < arc.id; }
-    };
-
-    Node source(const Arc& e) const { return Node(arc_source[e.id]); }
-    Node target(const Arc& e) const { return Node(arc_target[e.id]); }
-
-    void first(Node& n) const { n.id = node_num - 1; }
-    static void next(Node& n) { --n.id; }
-
-    void first(Arc& e) const { e.id = arc_num - 1; }
-    static void next(Arc& e) { --e.id; }
-
-    void firstOut(Arc& e, const Node& n) const {
-      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
-        node_first_out[n.id] : -1;
-    }
-    void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; }
-
-    void firstIn(Arc& e, const Node& n) const { e.id = node_first_in[n.id]; }
-    void nextIn(Arc& e) const { e.id = arc_next_in[e.id]; }
-
-    static int id(const Node& n) { return n.id; }
-    static Node nodeFromId(int id) { return Node(id); }
-    int maxNodeId() const { return node_num - 1; }
-
-    static int id(const Arc& e) { return e.id; }
-    static Arc arcFromId(int id) { return Arc(id); }
-    int maxArcId() const { return arc_num - 1; }
-
-    typedef True NodeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return node_num; }
-    int arcNum() const { return arc_num; }
-
-  private:
-
-    template <typename Digraph, typename NodeRefMap>
-    class ArcLess {
-    public:
-      typedef typename Digraph::Arc Arc;
-
-      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
-        : digraph(_graph), nodeRef(_nodeRef) {}
-
-      bool operator()(const Arc& left, const Arc& right) const {
-        return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
-      }
-    private:
-      const Digraph& digraph;
-      const NodeRefMap& nodeRef;
-    };
-
-  public:
-
-    typedef True BuildTag;
-
-    void clear() {
-      if (built) {
-        delete[] node_first_out;
-        delete[] node_first_in;
-        delete[] arc_source;
-        delete[] arc_target;
-        delete[] arc_next_out;
-        delete[] arc_next_in;
-      }
-      built = false;
-      node_num = 0;
-      arc_num = 0;
-    }
-
-    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
-    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
-      typedef typename Digraph::Node GNode;
-      typedef typename Digraph::Arc GArc;
-
-      built = true;
-
-      node_num = countNodes(digraph);
-      arc_num = countArcs(digraph);
-
-      node_first_out = new int[node_num + 1];
-      node_first_in = new int[node_num];
-
-      arc_source = new int[arc_num];
-      arc_target = new int[arc_num];
-      arc_next_out = new int[arc_num];
-      arc_next_in = new int[arc_num];
-
-      int node_index = 0;
-      for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
-        nodeRef[n] = Node(node_index);
-        node_first_in[node_index] = -1;
-        ++node_index;
-      }
-
-      ArcLess<Digraph, NodeRefMap> arcLess(digraph, nodeRef);
-
-      int arc_index = 0;
-      for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
-        int source = nodeRef[n].id;
-        std::vector<GArc> arcs;
-        for (typename Digraph::OutArcIt e(digraph, n); e != INVALID; ++e) {
-          arcs.push_back(e);
-        }
-        if (!arcs.empty()) {
-          node_first_out[source] = arc_index;
-          std::sort(arcs.begin(), arcs.end(), arcLess);
-          for (typename std::vector<GArc>::iterator it = arcs.begin();
-               it != arcs.end(); ++it) {
-            int target = nodeRef[digraph.target(*it)].id;
-            arcRef[*it] = Arc(arc_index);
-            arc_source[arc_index] = source;
-            arc_target[arc_index] = target;
-            arc_next_in[arc_index] = node_first_in[target];
-            node_first_in[target] = arc_index;
-            arc_next_out[arc_index] = arc_index + 1;
-            ++arc_index;
-          }
-          arc_next_out[arc_index - 1] = -1;
-        } else {
-          node_first_out[source] = arc_index;
-        }
-      }
-      node_first_out[node_num] = arc_num;
-    }
-
-    template <typename ArcListIterator>
-    void build(int n, ArcListIterator first, ArcListIterator last) {
-      built = true;
-
-      node_num = n;
-      arc_num = std::distance(first, last);
-
-      node_first_out = new int[node_num + 1];
-      node_first_in = new int[node_num];
-
-      arc_source = new int[arc_num];
-      arc_target = new int[arc_num];
-      arc_next_out = new int[arc_num];
-      arc_next_in = new int[arc_num];
-
-      for (int i = 0; i != node_num; ++i) {
-        node_first_in[i] = -1;
-      }
-
-      int arc_index = 0;
-      for (int i = 0; i != node_num; ++i) {
-        node_first_out[i] = arc_index;
-        for ( ; first != last && (*first).first == i; ++first) {
-          int j = (*first).second;
-          LEMON_ASSERT(j >= 0 && j < node_num,
-            "Wrong arc list for StaticDigraph::build()");
-          arc_source[arc_index] = i;
-          arc_target[arc_index] = j;
-          arc_next_in[arc_index] = node_first_in[j];
-          node_first_in[j] = arc_index;
-          arc_next_out[arc_index] = arc_index + 1;
-          ++arc_index;
-        }
-        if (arc_index > node_first_out[i])
-          arc_next_out[arc_index - 1] = -1;
-      }
-      LEMON_ASSERT(first == last,
-        "Wrong arc list for StaticDigraph::build()");
-      node_first_out[node_num] = arc_num;
-    }
-
-  protected:
-
-    void fastFirstOut(Arc& e, const Node& n) const {
-      e.id = node_first_out[n.id];
-    }
-
-    static void fastNextOut(Arc& e) {
-      ++e.id;
-    }
-    void fastLastOut(Arc& e, const Node& n) const {
-      e.id = node_first_out[n.id + 1];
-    }
-
-  protected:
-    bool built;
-    int node_num;
-    int arc_num;
-    int *node_first_out;
-    int *node_first_in;
-    int *arc_source;
-    int *arc_target;
-    int *arc_next_in;
-    int *arc_next_out;
-  };
-
-  typedef DigraphExtender<StaticDigraphBase> ExtendedStaticDigraphBase;
-
-
-  /// \ingroup graphs
-  ///
-  /// \brief A static directed graph class.
-  ///
-  /// \ref StaticDigraph is a highly efficient digraph implementation,
-  /// but it is fully static.
-  /// It stores only two \c int values for each node and only four \c int
-  /// values for each arc. Moreover it provides faster item iteration than
-  /// \ref ListDigraph and \ref SmartDigraph, especially using \c OutArcIt
-  /// iterators, since its arcs are stored in an appropriate order.
-  /// However it only provides build() and clear() functions and does not
-  /// support any other modification of the digraph.
-  ///
-  /// Since this digraph structure is completely static, its nodes and arcs
-  /// can be indexed with integers from the ranges <tt>[0..nodeNum()-1]</tt>
-  /// and <tt>[0..arcNum()-1]</tt>, respectively.
-  /// The index of an item is the same as its ID, it can be obtained
-  /// using the corresponding \ref index() or \ref concepts::Digraph::id()
-  /// "id()" function. A node or arc with a certain index can be obtained
-  /// using node() or arc().
-  ///
-  /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes and arcs.
-  ///
-  /// \sa concepts::Digraph
-  class StaticDigraph : public ExtendedStaticDigraphBase {
-  public:
-
-    typedef ExtendedStaticDigraphBase Parent;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Default constructor.
-    StaticDigraph() : Parent() {}
-
-    /// \brief The node with the given index.
-    ///
-    /// This function returns the node with the given index.
-    /// \sa index()
-    static Node node(int ix) { return Parent::nodeFromId(ix); }
-
-    /// \brief The arc with the given index.
-    ///
-    /// This function returns the arc with the given index.
-    /// \sa index()
-    static Arc arc(int ix) { return Parent::arcFromId(ix); }
-
-    /// \brief The index of the given node.
-    ///
-    /// This function returns the index of the the given node.
-    /// \sa node()
-    static int index(Node node) { return Parent::id(node); }
-
-    /// \brief The index of the given arc.
-    ///
-    /// This function returns the index of the the given arc.
-    /// \sa arc()
-    static int index(Arc arc) { return Parent::id(arc); }
-
-    /// \brief Number of nodes.
-    ///
-    /// This function returns the number of nodes.
-    int nodeNum() const { return node_num; }
-
-    /// \brief Number of arcs.
-    ///
-    /// This function returns the number of arcs.
-    int arcNum() const { return arc_num; }
-
-    /// \brief Build the digraph copying another digraph.
-    ///
-    /// This function builds the digraph copying another digraph of any
-    /// kind. It can be called more than once, but in such case, the whole
-    /// structure and all maps will be cleared and rebuilt.
-    ///
-    /// This method also makes possible to copy a digraph to a StaticDigraph
-    /// structure using \ref DigraphCopy.
-    ///
-    /// \param digraph An existing digraph to be copied.
-    /// \param nodeRef The node references will be copied into this map.
-    /// Its key type must be \c Digraph::Node and its value type must be
-    /// \c StaticDigraph::Node.
-    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
-    /// concept.
-    /// \param arcRef The arc references will be copied into this map.
-    /// Its key type must be \c Digraph::Arc and its value type must be
-    /// \c StaticDigraph::Arc.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///
-    /// \note If you do not need the arc references, then you could use
-    /// \ref NullMap for the last parameter. However the node references
-    /// are required by the function itself, thus they must be readable
-    /// from the map.
-    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
-    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
-      if (built) Parent::clear();
-      Parent::build(digraph, nodeRef, arcRef);
-    }
-
-    /// \brief Build the digraph from an arc list.
-    ///
-    /// This function builds the digraph from the given arc list.
-    /// It can be called more than once, but in such case, the whole
-    /// structure and all maps will be cleared and rebuilt.
-    ///
-    /// The list of the arcs must be given in the range <tt>[begin, end)</tt>
-    /// specified by STL compatible itartors whose \c value_type must be
-    /// <tt>std::pair<int,int></tt>.
-    /// Each arc must be specified by a pair of integer indices
-    /// from the range <tt>[0..n-1]</tt>. <i>The pairs must be in a
-    /// non-decreasing order with respect to their first values.</i>
-    /// If the k-th pair in the list is <tt>(i,j)</tt>, then
-    /// <tt>arc(k-1)</tt> will connect <tt>node(i)</tt> to <tt>node(j)</tt>.
-    ///
-    /// \param n The number of nodes.
-    /// \param begin An iterator pointing to the beginning of the arc list.
-    /// \param end An iterator pointing to the end of the arc list.
-    ///
-    /// For example, a simple digraph can be constructed like this.
-    /// \code
-    ///   std::vector<std::pair<int,int> > arcs;
-    ///   arcs.push_back(std::make_pair(0,1));
-    ///   arcs.push_back(std::make_pair(0,2));
-    ///   arcs.push_back(std::make_pair(1,3));
-    ///   arcs.push_back(std::make_pair(1,2));
-    ///   arcs.push_back(std::make_pair(3,0));
-    ///   StaticDigraph gr;
-    ///   gr.build(4, arcs.begin(), arcs.end());
-    /// \endcode
-    template <typename ArcListIterator>
-    void build(int n, ArcListIterator begin, ArcListIterator end) {
-      if (built) Parent::clear();
-      StaticDigraphBase::build(n, begin, end);
-      notifier(Node()).build();
-      notifier(Arc()).build();
-    }
-
-    /// \brief Clear the digraph.
-    ///
-    /// This function erases all nodes and arcs from the digraph.
-    void clear() {
-      Parent::clear();
-    }
-
-  protected:
-
-    using Parent::fastFirstOut;
-    using Parent::fastNextOut;
-    using Parent::fastLastOut;
-
-  public:
-
-    class OutArcIt : public Arc {
-    public:
-
-      OutArcIt() { }
-
-      OutArcIt(Invalid i) : Arc(i) { }
-
-      OutArcIt(const StaticDigraph& digraph, const Node& node) {
-        digraph.fastFirstOut(*this, node);
-        digraph.fastLastOut(last, node);
-        if (last == *this) *this = INVALID;
-      }
-
-      OutArcIt(const StaticDigraph& digraph, const Arc& arc) : Arc(arc) {
-        if (arc != INVALID) {
-          digraph.fastLastOut(last, digraph.source(arc));
-        }
-      }
-
-      OutArcIt& operator++() {
-        StaticDigraph::fastNextOut(*this);
-        if (last == *this) *this = INVALID;
-        return *this;
-      }
-
-    private:
-      Arc last;
-    };
-
-    Node baseNode(const OutArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-
-    Node runningNode(const OutArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-
-    Node baseNode(const InArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-
-    Node runningNode(const InArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-
-  };
-
-}
-
-#endif
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 1254)
+++ lemon/suurballe.h	(revision 925)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,51 +30,7 @@
 #include <lemon/path.h>
 #include <lemon/list_graph.h>
-#include <lemon/dijkstra.h>
 #include <lemon/maps.h>
 
 namespace lemon {
-
-  /// \brief Default traits class of Suurballe algorithm.
-  ///
-  /// Default traits class of Suurballe algorithm.
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam LEN The type of the length map.
-  /// The default value is <tt>GR::ArcMap<int></tt>.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN>
-#else
-  template < typename GR,
-             typename LEN = typename GR::template ArcMap<int> >
-#endif
-  struct SuurballeDefaultTraits
-  {
-    /// The type of the digraph.
-    typedef GR Digraph;
-    /// The type of the length map.
-    typedef LEN LengthMap;
-    /// The type of the lengths.
-    typedef typename LEN::Value Length;
-    /// The type of the flow map.
-    typedef typename GR::template ArcMap<int> FlowMap;
-    /// The type of the potential map.
-    typedef typename GR::template NodeMap<Length> PotentialMap;
-
-    /// \brief The path type
-    ///
-    /// The type used for storing the found arc-disjoint paths.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    typedef lemon::Path<Digraph> Path;
-
-    /// The cross reference type used for the heap.
-    typedef typename GR::template NodeMap<int> HeapCrossRef;
-
-    /// \brief The heap type used for internal Dijkstra computations.
-    ///
-    /// The type of the heap used for internal Dijkstra computations.
-    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept
-    /// and its priority type must be \c Length.
-    typedef BinHeap<Length, HeapCrossRef> Heap;
-  };
 
   /// \addtogroup shortest_path
@@ -91,5 +47,5 @@
   /// "minimum cost flow problem". This implementation is actually an
   /// efficient specialized version of the \ref CapacityScaling
-  /// "successive shortest path" algorithm directly for this problem.
+  /// "Successive Shortest Path" algorithm directly for this problem.
   /// Therefore this class provides query functions for flow values and
   /// node potentials (the dual solution) just like the minimum cost flow
@@ -102,12 +58,11 @@
   /// \warning Length values should be \e non-negative.
   ///
-  /// \note For finding \e node-disjoint paths, this algorithm can be used
+  /// \note For finding node-disjoint paths this algorithm can be used
   /// along with the \ref SplitNodes adaptor.
 #ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
+  template <typename GR, typename LEN>
 #else
   template < typename GR,
-             typename LEN = typename GR::template ArcMap<int>,
-             typename TR = SuurballeDefaultTraits<GR, LEN> >
+             typename LEN = typename GR::template ArcMap<int> >
 #endif
   class Suurballe
@@ -120,24 +75,24 @@
   public:
 
-    /// The type of the digraph.
-    typedef typename TR::Digraph Digraph;
+    /// The type of the digraph the algorithm runs on.
+    typedef GR Digraph;
     /// The type of the length map.
-    typedef typename TR::LengthMap LengthMap;
+    typedef LEN LengthMap;
     /// The type of the lengths.
-    typedef typename TR::Length Length;
-
+    typedef typename LengthMap::Value Length;
+#ifdef DOXYGEN
     /// The type of the flow map.
-    typedef typename TR::FlowMap FlowMap;
+    typedef GR::ArcMap<int> FlowMap;
     /// The type of the potential map.
-    typedef typename TR::PotentialMap PotentialMap;
+    typedef GR::NodeMap<Length> PotentialMap;
+#else
+    /// The type of the flow map.
+    typedef typename Digraph::template ArcMap<int> FlowMap;
+    /// The type of the potential map.
+    typedef typename Digraph::template NodeMap<Length> PotentialMap;
+#endif
+
     /// The type of the path structures.
-    typedef typename TR::Path Path;
-    /// The cross reference type used for the heap.
-    typedef typename TR::HeapCrossRef HeapCrossRef;
-    /// The heap type used for internal Dijkstra computations.
-    typedef typename TR::Heap Heap;
-
-    /// The \ref lemon::SuurballeDefaultTraits "traits class" of the algorithm.
-    typedef TR Traits;
+    typedef SimplePath<GR> Path;
 
   private:
@@ -150,36 +105,42 @@
     class ResidualDijkstra
     {
+      typedef typename Digraph::template NodeMap<int> HeapCrossRef;
+      typedef BinHeap<Length, HeapCrossRef> Heap;
+
     private:
 
+      // The digraph the algorithm runs on
       const Digraph &_graph;
+
+      // The main maps
+      const FlowMap &_flow;
       const LengthMap &_length;
-      const FlowMap &_flow;
-      PotentialMap &_pi;
+      PotentialMap &_potential;
+
+      // The distance map
+      PotentialMap _dist;
+      // The pred arc map
       PredMap &_pred;
+      // The processed (i.e. permanently labeled) nodes
+      std::vector<Node> _proc_nodes;
+
       Node _s;
       Node _t;
 
-      PotentialMap _dist;
-      std::vector<Node> _proc_nodes;
-
     public:
 
-      // Constructor
-      ResidualDijkstra(Suurballe &srb) :
-        _graph(srb._graph), _length(srb._length),
-        _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred),
-        _s(srb._s), _t(srb._t), _dist(_graph) {}
-
-      // Run the algorithm and return true if a path is found
-      // from the source node to the target node.
-      bool run(int cnt) {
-        return cnt == 0 ? startFirst() : start();
-      }
-
-    private:
-
-      // Execute the algorithm for the first time (the flow and potential
-      // functions have to be identically zero).
-      bool startFirst() {
+      /// Constructor.
+      ResidualDijkstra( const Digraph &graph,
+                        const FlowMap &flow,
+                        const LengthMap &length,
+                        PotentialMap &potential,
+                        PredMap &pred,
+                        Node s, Node t ) :
+        _graph(graph), _flow(flow), _length(length), _potential(potential),
+        _dist(graph), _pred(pred), _s(s), _t(t) {}
+
+      /// \brief Run the algorithm. It returns \c true if a path is found
+      /// from the source node to the target node.
+      bool run() {
         HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
         Heap heap(heap_cross_ref);
@@ -191,21 +152,22 @@
         while (!heap.empty() && heap.top() != _t) {
           Node u = heap.top(), v;
-          Length d = heap.prio(), dn;
+          Length d = heap.prio() + _potential[u], nd;
           _dist[u] = heap.prio();
+          heap.pop();
           _proc_nodes.push_back(u);
-          heap.pop();
 
           // Traverse outgoing arcs
           for (OutArcIt e(_graph, u); e != INVALID; ++e) {
-            v = _graph.target(e);
-            switch(heap.state(v)) {
+            if (_flow[e] == 0) {
+              v = _graph.target(e);
+              switch(heap.state(v)) {
               case Heap::PRE_HEAP:
-                heap.push(v, d + _length[e]);
+                heap.push(v, d + _length[e] - _potential[v]);
                 _pred[v] = e;
                 break;
               case Heap::IN_HEAP:
-                dn = d + _length[e];
-                if (dn < heap[v]) {
-                  heap.decrease(v, dn);
+                nd = d + _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
                   _pred[v] = e;
                 }
@@ -213,50 +175,4 @@
               case Heap::POST_HEAP:
                 break;
-            }
-          }
-        }
-        if (heap.empty()) return false;
-
-        // Update potentials of processed nodes
-        Length t_dist = heap.prio();
-        for (int i = 0; i < int(_proc_nodes.size()); ++i)
-          _pi[_proc_nodes[i]] = _dist[_proc_nodes[i]] - t_dist;
-        return true;
-      }
-
-      // Execute the algorithm.
-      bool start() {
-        HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
-        Heap heap(heap_cross_ref);
-        heap.push(_s, 0);
-        _pred[_s] = INVALID;
-        _proc_nodes.clear();
-
-        // Process nodes
-        while (!heap.empty() && heap.top() != _t) {
-          Node u = heap.top(), v;
-          Length d = heap.prio() + _pi[u], dn;
-          _dist[u] = heap.prio();
-          _proc_nodes.push_back(u);
-          heap.pop();
-
-          // Traverse outgoing arcs
-          for (OutArcIt e(_graph, u); e != INVALID; ++e) {
-            if (_flow[e] == 0) {
-              v = _graph.target(e);
-              switch(heap.state(v)) {
-                case Heap::PRE_HEAP:
-                  heap.push(v, d + _length[e] - _pi[v]);
-                  _pred[v] = e;
-                  break;
-                case Heap::IN_HEAP:
-                  dn = d + _length[e] - _pi[v];
-                  if (dn < heap[v]) {
-                    heap.decrease(v, dn);
-                    _pred[v] = e;
-                  }
-                  break;
-                case Heap::POST_HEAP:
-                  break;
               }
             }
@@ -268,17 +184,17 @@
               v = _graph.source(e);
               switch(heap.state(v)) {
-                case Heap::PRE_HEAP:
-                  heap.push(v, d - _length[e] - _pi[v]);
+              case Heap::PRE_HEAP:
+                heap.push(v, d - _length[e] - _potential[v]);
+                _pred[v] = e;
+                break;
+              case Heap::IN_HEAP:
+                nd = d - _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
                   _pred[v] = e;
-                  break;
-                case Heap::IN_HEAP:
-                  dn = d - _length[e] - _pi[v];
-                  if (dn < heap[v]) {
-                    heap.decrease(v, dn);
-                    _pred[v] = e;
-                  }
-                  break;
-                case Heap::POST_HEAP:
-                  break;
+                }
+                break;
+              case Heap::POST_HEAP:
+                break;
               }
             }
@@ -290,86 +206,9 @@
         Length t_dist = heap.prio();
         for (int i = 0; i < int(_proc_nodes.size()); ++i)
-          _pi[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
+          _potential[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
         return true;
       }
 
     }; //class ResidualDijkstra
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c FlowMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c FlowMap type.
-    template <typename T>
-    struct SetFlowMap
-      : public Suurballe<GR, LEN, SetFlowMapTraits<T> > {
-      typedef Suurballe<GR, LEN, SetFlowMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPotentialMapTraits : public Traits {
-      typedef T PotentialMap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c PotentialMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c PotentialMap type.
-    template <typename T>
-    struct SetPotentialMap
-      : public Suurballe<GR, LEN, SetPotentialMapTraits<T> > {
-      typedef Suurballe<GR, LEN, SetPotentialMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c %Path type.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    template <typename T>
-    struct SetPath
-      : public Suurballe<GR, LEN, SetPathTraits<T> > {
-      typedef Suurballe<GR, LEN, SetPathTraits<T> > Create;
-    };
-
-    template <typename H, typename CR>
-    struct SetHeapTraits : public Traits {
-      typedef H Heap;
-      typedef CR HeapCrossRef;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c Heap and \c HeapCrossRef types.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c Heap
-    /// and \c HeapCrossRef types with automatic allocation.
-    /// They will be used for internal Dijkstra computations.
-    /// The heap type must conform to the \ref lemon::concepts::Heap "Heap"
-    /// concept and its priority type must be \c Length.
-    template <typename H,
-              typename CR = typename Digraph::template NodeMap<int> >
-    struct SetHeap
-      : public Suurballe<GR, LEN, SetHeapTraits<H, CR> > {
-      typedef Suurballe<GR, LEN, SetHeapTraits<H, CR> > Create;
-    };
-
-    /// @}
 
   private:
@@ -388,23 +227,17 @@
 
     // The source node
-    Node _s;
+    Node _source;
     // The target node
-    Node _t;
+    Node _target;
 
     // Container to store the found paths
-    std::vector<Path> _paths;
+    std::vector< SimplePath<Digraph> > paths;
     int _path_num;
 
     // The pred arc map
     PredMap _pred;
-
-    // Data for full init
-    PotentialMap *_init_dist;
-    PredMap *_init_pred;
-    bool _full_init;
-
-  protected:
-
-    Suurballe() {}
+    // Implementation of the Dijkstra algorithm for finding augmenting
+    // shortest paths in the residual network
+    ResidualDijkstra *_dijkstra;
 
   public:
@@ -419,6 +252,5 @@
                const LengthMap &length ) :
       _graph(graph), _length(length), _flow(0), _local_flow(false),
-      _potential(0), _local_potential(false), _pred(graph),
-      _init_dist(0), _init_pred(0)
+      _potential(0), _local_potential(false), _pred(graph)
     {}
 
@@ -427,6 +259,5 @@
       if (_local_flow) delete _flow;
       if (_local_potential) delete _potential;
-      delete _init_dist;
-      delete _init_pred;
+      delete _dijkstra;
     }
 
@@ -473,11 +304,8 @@
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call the run()
-    /// function.\n
-    /// If you need to execute the algorithm many times using the same
-    /// source node, then you may call fullInit() once and start()
-    /// for each target node.\n
+    /// function.
+    /// \n
     /// If you only need the flow that is the union of the found
-    /// arc-disjoint paths, then you may call findFlow() instead of
-    /// start().
+    /// arc-disjoint paths, you may call init() and findFlow().
 
     /// @{
@@ -499,9 +327,11 @@
     /// \code
     ///   s.init(s);
-    ///   s.start(t, k);
+    ///   s.findFlow(t, k);
+    ///   s.findPaths();
     /// \endcode
     int run(const Node& s, const Node& t, int k = 2) {
       init(s);
-      start(t, k);
+      findFlow(t, k);
+      findPaths();
       return _path_num;
     }
@@ -509,9 +339,9 @@
     /// \brief Initialize the algorithm.
     ///
-    /// This function initializes the algorithm with the given source node.
+    /// This function initializes the algorithm.
     ///
     /// \param s The source node.
     void init(const Node& s) {
-      _s = s;
+      _source = s;
 
       // Initialize maps
@@ -524,61 +354,6 @@
         _local_potential = true;
       }
-      _full_init = false;
-    }
-
-    /// \brief Initialize the algorithm and perform Dijkstra.
-    ///
-    /// This function initializes the algorithm and performs a full
-    /// Dijkstra search from the given source node. It makes consecutive
-    /// executions of \ref start() "start(t, k)" faster, since they
-    /// have to perform %Dijkstra only k-1 times.
-    ///
-    /// This initialization is usually worth using instead of \ref init()
-    /// if the algorithm is executed many times using the same source node.
-    ///
-    /// \param s The source node.
-    void fullInit(const Node& s) {
-      // Initialize maps
-      init(s);
-      if (!_init_dist) {
-        _init_dist = new PotentialMap(_graph);
-      }
-      if (!_init_pred) {
-        _init_pred = new PredMap(_graph);
-      }
-
-      // Run a full Dijkstra
-      typename Dijkstra<Digraph, LengthMap>
-        ::template SetStandardHeap<Heap>
-        ::template SetDistMap<PotentialMap>
-        ::template SetPredMap<PredMap>
-        ::Create dijk(_graph, _length);
-      dijk.distMap(*_init_dist).predMap(*_init_pred);
-      dijk.run(s);
-
-      _full_init = true;
-    }
-
-    /// \brief Execute the algorithm.
-    ///
-    /// This function executes the algorithm.
-    ///
-    /// \param t The target node.
-    /// \param k The number of paths to be found.
-    ///
-    /// \return \c k if there are at least \c k arc-disjoint paths from
-    /// \c s to \c t in the digraph. Otherwise it returns the number of
-    /// arc-disjoint paths found.
-    ///
-    /// \note Apart from the return value, <tt>s.start(t, k)</tt> is
-    /// just a shortcut of the following code.
-    /// \code
-    ///   s.findFlow(t, k);
-    ///   s.findPaths();
-    /// \endcode
-    int start(const Node& t, int k = 2) {
-      findFlow(t, k);
-      findPaths();
-      return _path_num;
+      for (ArcIt e(_graph); e != INVALID; ++e) (*_flow)[e] = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n) (*_potential)[n] = 0;
     }
 
@@ -598,37 +373,18 @@
     /// \pre \ref init() must be called before using this function.
     int findFlow(const Node& t, int k = 2) {
-      _t = t;
-      ResidualDijkstra dijkstra(*this);
-
-      // Initialization
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_flow)[e] = 0;
-      }
-      if (_full_init) {
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          (*_potential)[n] = (*_init_dist)[n];
-        }
-        Node u = _t;
-        Arc e;
-        while ((e = (*_init_pred)[u]) != INVALID) {
-          (*_flow)[e] = 1;
-          u = _graph.source(e);
-        }
-        _path_num = 1;
-      } else {
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          (*_potential)[n] = 0;
-        }
-        _path_num = 0;
-      }
+      _target = t;
+      _dijkstra =
+        new ResidualDijkstra( _graph, *_flow, _length, *_potential, _pred,
+                              _source, _target );
 
       // Find shortest paths
+      _path_num = 0;
       while (_path_num < k) {
         // Run Dijkstra
-        if (!dijkstra.run(_path_num)) break;
+        if (!_dijkstra->run()) break;
         ++_path_num;
 
         // Set the flow along the found shortest path
-        Node u = _t;
+        Node u = _target;
         Arc e;
         while ((e = _pred[u]) != INVALID) {
@@ -647,6 +403,6 @@
     /// \brief Compute the paths from the flow.
     ///
-    /// This function computes arc-disjoint paths from the found minimum
-    /// cost flow, which is the union of them.
+    /// This function computes the paths from the found minimum cost flow,
+    /// which is the union of some arc-disjoint paths.
     ///
     /// \pre \ref init() and \ref findFlow() must be called before using
@@ -656,13 +412,13 @@
       for(ArcIt a(_graph); a != INVALID; ++a) res_flow[a] = (*_flow)[a];
 
-      _paths.clear();
-      _paths.resize(_path_num);
+      paths.clear();
+      paths.resize(_path_num);
       for (int i = 0; i < _path_num; ++i) {
-        Node n = _s;
-        while (n != _t) {
+        Node n = _source;
+        while (n != _target) {
           OutArcIt e(_graph, n);
           for ( ; res_flow[e] == 0; ++e) ;
           n = _graph.target(e);
-          _paths[i].addBack(e);
+          paths[i].addBack(e);
           res_flow[e] = 0;
         }
@@ -683,5 +439,5 @@
     /// This function returns the total length of the found paths, i.e.
     /// the total cost of the found flow.
-    /// The complexity of the function is O(m).
+    /// The complexity of the function is O(e).
     ///
     /// \pre \ref run() or \ref findFlow() must be called before using
@@ -763,5 +519,5 @@
     /// this function.
     const Path& path(int i) const {
-      return _paths[i];
+      return paths[i];
     }
 
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 1222)
+++ lemon/time_measure.h	(revision 631)
@@ -35,5 +35,4 @@
 #include <fstream>
 #include <iostream>
-#include <lemon/math.h>
 
 namespace lemon {
@@ -65,19 +64,4 @@
     double rtime;
 
-  public:
-    ///Display format specifier
-
-    ///\e
-    ///
-    enum Format {
-      /// Reports all measured values
-      NORMAL = 0,
-      /// Only real time and an error indicator is displayed
-      SHORT = 1
-    };
-
-  private:
-    static Format _format;
-
     void _reset() {
       utime = stime = cutime = cstime = rtime = 0;
@@ -86,18 +70,4 @@
   public:
 
-    ///Set output format
-
-    ///Set output format.
-    ///
-    ///The output format is global for all timestamp instances.
-    static void format(Format f) { _format = f; }
-    ///Retrieve the current output format
-
-    ///Retrieve the current output format
-    ///
-    ///The output format is global for all timestamp instances.
-    static Format format() { return _format; }
-
-    
     ///Read the current time values of the process
     void stamp()
@@ -255,22 +225,9 @@
   inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
   {
-    switch(t._format)
-      {
-      case TimeStamp::NORMAL:
-        os << "u: " << t.userTime() <<
-          "s, s: " << t.systemTime() <<
-          "s, cu: " << t.cUserTime() <<
-          "s, cs: " << t.cSystemTime() <<
-          "s, real: " << t.realTime() << "s";
-        break;
-      case TimeStamp::SHORT:
-        double total = t.userTime()+t.systemTime()+
-          t.cUserTime()+t.cSystemTime();
-        os << t.realTime()
-           << "s (err: " << round((t.realTime()-total)/
-                                  t.realTime()*10000)/100
-           << "%)";
-        break;
-      }
+    os << "u: " << t.userTime() <<
+      "s, s: " << t.systemTime() <<
+      "s, cu: " << t.cUserTime() <<
+      "s, cs: " << t.cSystemTime() <<
+      "s, real: " << t.realTime() << "s";
     return os;
   }
@@ -419,5 +376,5 @@
     ///This function returns the number of stop() exections that is
     ///necessary to really stop the timer.
-    ///For example, the timer
+    ///For example the timer
     ///is running if and only if the return value is \c true
     ///(i.e. greater than
@@ -512,5 +469,4 @@
     std::string _title;
     std::ostream &_os;
-    bool _active;
   public:
     ///Constructor
@@ -520,25 +476,11 @@
     ///\param os The stream to print the report to.
     ///\param run Sets whether the timer should start immediately.
-    ///\param active Sets whether the report should actually be printed
-    ///       on destruction.
-    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true,
-	       bool active=true)
-      : Timer(run), _title(title), _os(os), _active(active) {}
+    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true)
+      : Timer(run), _title(title), _os(os){}
     ///Destructor that prints the ellapsed time
     ~TimeReport()
     {
-      if(_active) _os << _title << *this << std::endl;
-    }
-    
-    ///Retrieve the activity status
-
-    ///\e
-    ///
-    bool active() const { return _active; }
-    ///Set the activity status
-
-    /// This function set whether the time report should actually be printed
-    /// on destruction.
-    void active(bool a) { _active=a; }
+      _os << _title << *this << std::endl;
+    }
   };
 
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 956)
+++ lemon/unionfind.h	(revision 945)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -44,5 +44,5 @@
   /// This is a very simple but efficient implementation, providing
   /// only four methods: join (union), find, insert and size.
-  /// For more features, see the \ref UnionFindEnum class.
+  /// For more features see the \ref UnionFindEnum class.
   ///
   /// It is primarily used in Kruskal algorithm for finding minimal
