Index: lemon/CMakeLists.txt
===================================================================
--- lemon/CMakeLists.txt	(revision 726)
+++ lemon/CMakeLists.txt	(revision 674)
@@ -26,32 +26,28 @@
     INSTALL(FILES ${GLPK_BIN_DIR}/libltdl3.dll DESTINATION bin)
     INSTALL(FILES ${GLPK_BIN_DIR}/zlib1.dll DESTINATION bin)
-  ENDIF()
-ENDIF()
+  ENDIF(WIN32)
+ENDIF(LEMON_HAVE_GLPK)
 
 IF(LEMON_HAVE_CPLEX)
   SET(LEMON_SOURCES ${LEMON_SOURCES} cplex.cc)
   INCLUDE_DIRECTORIES(${CPLEX_INCLUDE_DIRS})
-ENDIF()
+ENDIF(LEMON_HAVE_CPLEX)
 
 IF(LEMON_HAVE_CLP)
   SET(LEMON_SOURCES ${LEMON_SOURCES} clp.cc)
   INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})
-ENDIF()
+ENDIF(LEMON_HAVE_CLP)
 
 IF(LEMON_HAVE_CBC)
   SET(LEMON_SOURCES ${LEMON_SOURCES} cbc.cc)
   INCLUDE_DIRECTORIES(${COIN_INCLUDE_DIRS})
-ENDIF()
+ENDIF(LEMON_HAVE_CBC)
 
 ADD_LIBRARY(lemon ${LEMON_SOURCES})
-IF(UNIX)
-  SET_TARGET_PROPERTIES(lemon PROPERTIES OUTPUT_NAME emon)
-ENDIF()
 
 INSTALL(
   TARGETS lemon
   ARCHIVE DESTINATION lib
-  COMPONENT library
-)
+  COMPONENT library)
 
 INSTALL(
@@ -59,10 +55,8 @@
   DESTINATION include/lemon
   COMPONENT headers
-  FILES_MATCHING PATTERN "*.h"
-)
+  FILES_MATCHING PATTERN "*.h")
 
 INSTALL(
   FILES ${CMAKE_CURRENT_BINARY_DIR}/config.h
   DESTINATION include/lemon
-  COMPONENT headers
-)
+  COMPONENT headers)
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am	(revision 827)
+++ lemon/Makefile.am	(revision 686)
@@ -1,6 +1,5 @@
 EXTRA_DIST += \
 	lemon/lemon.pc.in \
-	lemon/CMakeLists.txt \
-	lemon/config.h.cmake
+	lemon/CMakeLists.txt
 
 pkgconfig_DATA += lemon/lemon.pc
@@ -18,5 +17,5 @@
 
 nodist_lemon_HEADERS = lemon/config.h	
-
+	
 lemon_libemon_la_CXXFLAGS = \
 	$(AM_CXXFLAGS) \
@@ -58,9 +57,6 @@
 	lemon/arg_parser.h \
 	lemon/assert.h \
-	lemon/bellman_ford.h \
 	lemon/bfs.h \
 	lemon/bin_heap.h \
-	lemon/binom_heap.h \
-	lemon/bucket_heap.h \
 	lemon/cbc.h \
 	lemon/circulation.h \
@@ -80,6 +76,4 @@
 	lemon/error.h \
 	lemon/euler.h \
-	lemon/fib_heap.h \
-	lemon/fourary_heap.h \
 	lemon/full_graph.h \
 	lemon/glpk.h \
@@ -87,9 +81,5 @@
 	lemon/graph_to_eps.h \
 	lemon/grid_graph.h \
-	lemon/hartmann_orlin.h \
-	lemon/howard.h \
 	lemon/hypercube_graph.h \
-	lemon/karp.h \
-	lemon/kary_heap.h \
 	lemon/kruskal.h \
 	lemon/hao_orlin.h \
@@ -100,4 +90,5 @@
 	lemon/lp_base.h \
 	lemon/lp_skeleton.h \
+	lemon/list_graph.h \
 	lemon/maps.h \
 	lemon/matching.h \
@@ -106,13 +97,10 @@
 	lemon/nauty_reader.h \
 	lemon/network_simplex.h \
-	lemon/pairing_heap.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/static_graph.h \
 	lemon/suurballe.h \
 	lemon/time_measure.h \
@@ -124,4 +112,5 @@
 	lemon/bits/alteration_notifier.h \
 	lemon/bits/array_map.h \
+	lemon/bits/base_extender.h \
 	lemon/bits/bezier.h \
 	lemon/bits/default_map.h \
Index: lemon/adaptors.h
===================================================================
--- lemon/adaptors.h	(revision 834)
+++ lemon/adaptors.h	(revision 664)
@@ -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.
@@ -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.
@@ -1320,6 +1315,4 @@
   /// 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.
   /// It must conform to the \ref concepts::Graph "Graph" concept.
@@ -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.
@@ -1629,6 +1620,4 @@
   /// 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.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
@@ -1741,6 +1730,4 @@
   /// 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.
   /// It must conform to the \ref concepts::Graph "Graph" concept.
@@ -1853,29 +1840,29 @@
     typedef typename Digraph::Node Node;
 
-    class Arc {
+    class Arc : public Edge {
       friend class UndirectorBase;
     protected:
-      Edge _edge;
       bool _forward;
 
-      Arc(const Edge& edge, bool forward) 
-        : _edge(edge), _forward(forward) {}
+      Arc(const Edge& edge, bool forward) :
+        Edge(edge), _forward(forward) {}
 
     public:
       Arc() {}
 
-      Arc(Invalid) : _edge(INVALID), _forward(true) {}
-
-      operator const Edge&() const { return _edge; }
+      Arc(Invalid) : Edge(INVALID), _forward(true) {}
 
       bool operator==(const Arc &other) const {
-        return _forward == other._forward && _edge == other._edge;
+        return _forward == other._forward &&
+          static_cast<const Edge&>(*this) == static_cast<const Edge&>(other);
       }
       bool operator!=(const Arc &other) const {
-        return _forward != other._forward || _edge != other._edge;
+        return _forward != other._forward ||
+          static_cast<const Edge&>(*this) != static_cast<const Edge&>(other);
       }
       bool operator<(const Arc &other) const {
         return _forward < other._forward ||
-          (_forward == other._forward && _edge < other._edge);
+          (_forward == other._forward &&
+           static_cast<const Edge&>(*this) < static_cast<const Edge&>(other));
       }
     };
@@ -1890,5 +1877,5 @@
 
     void first(Arc& a) const {
-      _digraph->first(a._edge);
+      _digraph->first(a);
       a._forward = true;
     }
@@ -1898,5 +1885,5 @@
         a._forward = false;
       } else {
-        _digraph->next(a._edge);
+        _digraph->next(a);
         a._forward = true;
       }
@@ -1912,9 +1899,9 @@
 
     void firstOut(Arc& a, const Node& n) const {
-      _digraph->firstIn(a._edge, n);
-      if (a._edge != INVALID ) {
+      _digraph->firstIn(a, n);
+      if( static_cast<const Edge&>(a) != INVALID ) {
         a._forward = false;
       } else {
-        _digraph->firstOut(a._edge, n);
+        _digraph->firstOut(a, n);
         a._forward = true;
       }
@@ -1922,22 +1909,22 @@
     void nextOut(Arc &a) const {
       if (!a._forward) {
-        Node n = _digraph->target(a._edge);
-        _digraph->nextIn(a._edge);
-        if (a._edge == INVALID) {
-          _digraph->firstOut(a._edge, n);
+        Node n = _digraph->target(a);
+        _digraph->nextIn(a);
+        if (static_cast<const Edge&>(a) == INVALID ) {
+          _digraph->firstOut(a, n);
           a._forward = true;
         }
       }
       else {
-        _digraph->nextOut(a._edge);
+        _digraph->nextOut(a);
       }
     }
 
     void firstIn(Arc &a, const Node &n) const {
-      _digraph->firstOut(a._edge, n);
-      if (a._edge != INVALID ) {
+      _digraph->firstOut(a, n);
+      if (static_cast<const Edge&>(a) != INVALID ) {
         a._forward = false;
       } else {
-        _digraph->firstIn(a._edge, n);
+        _digraph->firstIn(a, n);
         a._forward = true;
       }
@@ -1945,13 +1932,13 @@
     void nextIn(Arc &a) const {
       if (!a._forward) {
-        Node n = _digraph->source(a._edge);
-        _digraph->nextOut(a._edge);
-        if (a._edge == INVALID ) {
-          _digraph->firstIn(a._edge, n);
+        Node n = _digraph->source(a);
+        _digraph->nextOut(a);
+        if( static_cast<const Edge&>(a) == INVALID ) {
+          _digraph->firstIn(a, n);
           a._forward = true;
         }
       }
       else {
-        _digraph->nextIn(a._edge);
+        _digraph->nextIn(a);
       }
     }
@@ -1986,13 +1973,16 @@
 
     Node source(const Arc &a) const {
-      return a._forward ? _digraph->source(a._edge) : _digraph->target(a._edge);
+      return a._forward ? _digraph->source(a) : _digraph->target(a);
     }
 
     Node target(const Arc &a) const {
-      return a._forward ? _digraph->target(a._edge) : _digraph->source(a._edge);
+      return a._forward ? _digraph->target(a) : _digraph->source(a);
     }
 
     static Arc direct(const Edge &e, bool d) {
       return Arc(e, d);
+    }
+    Arc direct(const Edge &e, const Node& n) const {
+      return Arc(e, _digraph->source(e) == n);
     }
 
@@ -2246,7 +2236,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.
@@ -2551,7 +2538,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.
@@ -2697,6 +2681,4 @@
   /// arcs).
   /// 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.
@@ -3347,7 +3329,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.
Index: lemon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 835)
+++ 	(revision )
@@ -1,1101 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * 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(ne)</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>".
-#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 BellmanFordDefaultOperationTraits
-    /// "operation traits class" of the algorithm.
-    typedef typename TR::OperationTraits OperationTraits;
-
-    ///The \ref 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);
-      }
-      _mask = new MaskMap(*_gr, false);
-    }
-    
-  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);
-	}
-      }
-    }
-    
-    /// \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.
-  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 835)
+++ lemon/bfs.h	(revision 525)
@@ -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,5 +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.
@@ -98,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.
@@ -227,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> > {
@@ -247,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> > {
@@ -267,5 +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> > {
@@ -287,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> > {
@@ -415,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.
@@ -702,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.
@@ -735,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).
@@ -745,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
@@ -756,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
@@ -765,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()
@@ -771,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()
@@ -801,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()
@@ -807,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).
@@ -833,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.
@@ -848,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.
@@ -868,5 +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.
@@ -883,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.
@@ -898,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;
   };
@@ -904,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>
@@ -933,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),
@@ -963,4 +968,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -970,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;
 
@@ -1043,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()
     {
@@ -1056,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)
@@ -1075,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)
@@ -1094,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)
@@ -1114,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)
@@ -1258,5 +1265,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;
 
@@ -1419,6 +1426,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.
@@ -1692,6 +1699,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.
@@ -1725,5 +1736,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 631)
@@ -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
+  ///\ingroup auxdat
   ///
-  /// \brief Binary heap data structure.
+  ///\brief A Binary Heap implementation.
   ///
-  /// This class implements the \e binary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///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 Comp 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 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
+  ///\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 Comp 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 Comp = std::less<PR> >
   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.
-    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
+    ///\e
+    typedef Comp Compare;
+
+    /// \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/binom_heap.h
===================================================================
--- lemon/binom_heap.h	(revision 754)
+++ 	(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-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_BINOM_HEAP_H
-#define LEMON_BINOM_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 BinomHeap {
-  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 BinomHeap(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.
-    BinomHeap(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 BinomHeap;
-
-      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_BINOM_HEAP_H
-
Index: lemon/bits/base_extender.h
===================================================================
--- lemon/bits/base_extender.h	(revision 664)
+++ lemon/bits/base_extender.h	(revision 664)
@@ -0,0 +1,495 @@
+/* -*- 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_BITS_BASE_EXTENDER_H
+#define LEMON_BITS_BASE_EXTENDER_H
+
+#include <lemon/core.h>
+#include <lemon/error.h>
+
+#include <lemon/bits/map_extender.h>
+#include <lemon/bits/default_map.h>
+
+#include <lemon/concept_check.h>
+#include <lemon/concepts/maps.h>
+
+//\ingroup digraphbits
+//\file
+//\brief Extenders for the graph types
+namespace lemon {
+
+  // \ingroup digraphbits
+  //
+  // \brief BaseDigraph to BaseGraph extender
+  template <typename Base>
+  class UndirDigraphExtender : public Base {
+    typedef Base Parent;
+
+  public:
+
+    typedef typename Parent::Arc Edge;
+    typedef typename Parent::Node Node;
+
+    typedef True UndirectedTag;
+
+    class Arc : public Edge {
+      friend class UndirDigraphExtender;
+
+    protected:
+      bool forward;
+
+      Arc(const Edge &ue, bool _forward) :
+        Edge(ue), forward(_forward) {}
+
+    public:
+      Arc() {}
+
+      // Invalid arc constructor
+      Arc(Invalid i) : Edge(i), forward(true) {}
+
+      bool operator==(const Arc &that) const {
+        return forward==that.forward && Edge(*this)==Edge(that);
+      }
+      bool operator!=(const Arc &that) const {
+        return forward!=that.forward || Edge(*this)!=Edge(that);
+      }
+      bool operator<(const Arc &that) const {
+        return forward<that.forward ||
+          (!(that.forward<forward) && Edge(*this)<Edge(that));
+      }
+    };
+
+    // First node of the edge
+    Node u(const Edge &e) const {
+      return Parent::source(e);
+    }
+
+    // Source of the given arc
+    Node source(const Arc &e) const {
+      return e.forward ? Parent::source(e) : Parent::target(e);
+    }
+
+    // Second node of the edge
+    Node v(const Edge &e) const {
+      return Parent::target(e);
+    }
+
+    // Target of the given arc
+    Node target(const Arc &e) const {
+      return e.forward ? Parent::target(e) : Parent::source(e);
+    }
+
+    // \brief Directed arc from an edge.
+    //
+    // Returns a directed arc corresponding to the specified edge.
+    // If the given bool is true, the first node of the given edge and
+    // the source node of the returned arc are the same.
+    static Arc direct(const Edge &e, bool d) {
+      return Arc(e, d);
+    }
+
+    // Returns whether the given directed arc has the same orientation
+    // as the corresponding edge.
+    static bool direction(const Arc &a) { return a.forward; }
+
+    using Parent::first;
+    using Parent::next;
+
+    void first(Arc &e) const {
+      Parent::first(e);
+      e.forward=true;
+    }
+
+    void next(Arc &e) const {
+      if( e.forward ) {
+        e.forward = false;
+      }
+      else {
+        Parent::next(e);
+        e.forward = true;
+      }
+    }
+
+    void firstOut(Arc &e, const Node &n) const {
+      Parent::firstIn(e,n);
+      if( Edge(e) != INVALID ) {
+        e.forward = false;
+      }
+      else {
+        Parent::firstOut(e,n);
+        e.forward = true;
+      }
+    }
+    void nextOut(Arc &e) const {
+      if( ! e.forward ) {
+        Node n = Parent::target(e);
+        Parent::nextIn(e);
+        if( Edge(e) == INVALID ) {
+          Parent::firstOut(e, n);
+          e.forward = true;
+        }
+      }
+      else {
+        Parent::nextOut(e);
+      }
+    }
+
+    void firstIn(Arc &e, const Node &n) const {
+      Parent::firstOut(e,n);
+      if( Edge(e) != INVALID ) {
+        e.forward = false;
+      }
+      else {
+        Parent::firstIn(e,n);
+        e.forward = true;
+      }
+    }
+    void nextIn(Arc &e) const {
+      if( ! e.forward ) {
+        Node n = Parent::source(e);
+        Parent::nextOut(e);
+        if( Edge(e) == INVALID ) {
+          Parent::firstIn(e, n);
+          e.forward = true;
+        }
+      }
+      else {
+        Parent::nextIn(e);
+      }
+    }
+
+    void firstInc(Edge &e, bool &d, const Node &n) const {
+      d = true;
+      Parent::firstOut(e, n);
+      if (e != INVALID) return;
+      d = false;
+      Parent::firstIn(e, n);
+    }
+
+    void nextInc(Edge &e, bool &d) const {
+      if (d) {
+        Node s = Parent::source(e);
+        Parent::nextOut(e);
+        if (e != INVALID) return;
+        d = false;
+        Parent::firstIn(e, s);
+      } else {
+        Parent::nextIn(e);
+      }
+    }
+
+    Node nodeFromId(int ix) const {
+      return Parent::nodeFromId(ix);
+    }
+
+    Arc arcFromId(int ix) const {
+      return direct(Parent::arcFromId(ix >> 1), bool(ix & 1));
+    }
+
+    Edge edgeFromId(int ix) const {
+      return Parent::arcFromId(ix);
+    }
+
+    int id(const Node &n) const {
+      return Parent::id(n);
+    }
+
+    int id(const Edge &e) const {
+      return Parent::id(e);
+    }
+
+    int id(const Arc &e) const {
+      return 2 * Parent::id(e) + int(e.forward);
+    }
+
+    int maxNodeId() const {
+      return Parent::maxNodeId();
+    }
+
+    int maxArcId() const {
+      return 2 * Parent::maxArcId() + 1;
+    }
+
+    int maxEdgeId() const {
+      return Parent::maxArcId();
+    }
+
+    int arcNum() const {
+      return 2 * Parent::arcNum();
+    }
+
+    int edgeNum() const {
+      return Parent::arcNum();
+    }
+
+    Arc findArc(Node s, Node t, Arc p = INVALID) const {
+      if (p == INVALID) {
+        Edge arc = Parent::findArc(s, t);
+        if (arc != INVALID) return direct(arc, true);
+        arc = Parent::findArc(t, s);
+        if (arc != INVALID) return direct(arc, false);
+      } else if (direction(p)) {
+        Edge arc = Parent::findArc(s, t, p);
+        if (arc != INVALID) return direct(arc, true);
+        arc = Parent::findArc(t, s);
+        if (arc != INVALID) return direct(arc, false);
+      } else {
+        Edge arc = Parent::findArc(t, s, p);
+        if (arc != INVALID) return direct(arc, false);
+      }
+      return INVALID;
+    }
+
+    Edge findEdge(Node s, Node t, Edge p = INVALID) const {
+      if (s != t) {
+        if (p == INVALID) {
+          Edge arc = Parent::findArc(s, t);
+          if (arc != INVALID) return arc;
+          arc = Parent::findArc(t, s);
+          if (arc != INVALID) return arc;
+        } else if (Parent::s(p) == s) {
+          Edge arc = Parent::findArc(s, t, p);
+          if (arc != INVALID) return arc;
+          arc = Parent::findArc(t, s);
+          if (arc != INVALID) return arc;
+        } else {
+          Edge arc = Parent::findArc(t, s, p);
+          if (arc != INVALID) return arc;
+        }
+      } else {
+        return Parent::findArc(s, t, p);
+      }
+      return INVALID;
+    }
+  };
+
+  template <typename Base>
+  class BidirBpGraphExtender : public Base {
+    typedef Base Parent;
+
+  public:
+    typedef BidirBpGraphExtender Digraph;
+
+    typedef typename Parent::Node Node;
+    typedef typename Parent::Edge Edge;
+
+
+    using Parent::first;
+    using Parent::next;
+
+    using Parent::id;
+
+    class Red : public Node {
+      friend class BidirBpGraphExtender;
+    public:
+      Red() {}
+      Red(const Node& node) : Node(node) {
+        LEMON_DEBUG(Parent::red(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+      }
+      Red& operator=(const Node& node) {
+        LEMON_DEBUG(Parent::red(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+        Node::operator=(node);
+        return *this;
+      }
+      Red(Invalid) : Node(INVALID) {}
+      Red& operator=(Invalid) {
+        Node::operator=(INVALID);
+        return *this;
+      }
+    };
+
+    void first(Red& node) const {
+      Parent::firstRed(static_cast<Node&>(node));
+    }
+    void next(Red& node) const {
+      Parent::nextRed(static_cast<Node&>(node));
+    }
+
+    int id(const Red& node) const {
+      return Parent::redId(node);
+    }
+
+    class Blue : public Node {
+      friend class BidirBpGraphExtender;
+    public:
+      Blue() {}
+      Blue(const Node& node) : Node(node) {
+        LEMON_DEBUG(Parent::blue(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+      }
+      Blue& operator=(const Node& node) {
+        LEMON_DEBUG(Parent::blue(node) || node == INVALID,
+                    typename Parent::NodeSetError());
+        Node::operator=(node);
+        return *this;
+      }
+      Blue(Invalid) : Node(INVALID) {}
+      Blue& operator=(Invalid) {
+        Node::operator=(INVALID);
+        return *this;
+      }
+    };
+
+    void first(Blue& node) const {
+      Parent::firstBlue(static_cast<Node&>(node));
+    }
+    void next(Blue& node) const {
+      Parent::nextBlue(static_cast<Node&>(node));
+    }
+
+    int id(const Blue& node) const {
+      return Parent::redId(node);
+    }
+
+    Node source(const Edge& arc) const {
+      return red(arc);
+    }
+    Node target(const Edge& arc) const {
+      return blue(arc);
+    }
+
+    void firstInc(Edge& arc, bool& dir, const Node& node) const {
+      if (Parent::red(node)) {
+        Parent::firstFromRed(arc, node);
+        dir = true;
+      } else {
+        Parent::firstFromBlue(arc, node);
+        dir = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+    void nextInc(Edge& arc, bool& dir) const {
+      if (dir) {
+        Parent::nextFromRed(arc);
+      } else {
+        Parent::nextFromBlue(arc);
+        if (arc == INVALID) dir = true;
+      }
+    }
+
+    class Arc : public Edge {
+      friend class BidirBpGraphExtender;
+    protected:
+      bool forward;
+
+      Arc(const Edge& arc, bool _forward)
+        : Edge(arc), forward(_forward) {}
+
+    public:
+      Arc() {}
+      Arc (Invalid) : Edge(INVALID), forward(true) {}
+      bool operator==(const Arc& i) const {
+        return Edge::operator==(i) && forward == i.forward;
+      }
+      bool operator!=(const Arc& i) const {
+        return Edge::operator!=(i) || forward != i.forward;
+      }
+      bool operator<(const Arc& i) const {
+        return Edge::operator<(i) ||
+          (!(i.forward<forward) && Edge(*this)<Edge(i));
+      }
+    };
+
+    void first(Arc& arc) const {
+      Parent::first(static_cast<Edge&>(arc));
+      arc.forward = true;
+    }
+
+    void next(Arc& arc) const {
+      if (!arc.forward) {
+        Parent::next(static_cast<Edge&>(arc));
+      }
+      arc.forward = !arc.forward;
+    }
+
+    void firstOut(Arc& arc, const Node& node) const {
+      if (Parent::red(node)) {
+        Parent::firstFromRed(arc, node);
+        arc.forward = true;
+      } else {
+        Parent::firstFromBlue(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+    void nextOut(Arc& arc) const {
+      if (arc.forward) {
+        Parent::nextFromRed(arc);
+      } else {
+        Parent::nextFromBlue(arc);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+
+    void firstIn(Arc& arc, const Node& node) const {
+      if (Parent::blue(node)) {
+        Parent::firstFromBlue(arc, node);
+        arc.forward = true;
+      } else {
+        Parent::firstFromRed(arc, node);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+    void nextIn(Arc& arc) const {
+      if (arc.forward) {
+        Parent::nextFromBlue(arc);
+      } else {
+        Parent::nextFromRed(arc);
+        arc.forward = static_cast<Edge&>(arc) == INVALID;
+      }
+    }
+
+    Node source(const Arc& arc) const {
+      return arc.forward ? Parent::red(arc) : Parent::blue(arc);
+    }
+    Node target(const Arc& arc) const {
+      return arc.forward ? Parent::blue(arc) : Parent::red(arc);
+    }
+
+    int id(const Arc& arc) const {
+      return (Parent::id(static_cast<const Edge&>(arc)) << 1) +
+        (arc.forward ? 0 : 1);
+    }
+    Arc arcFromId(int ix) const {
+      return Arc(Parent::fromEdgeId(ix >> 1), (ix & 1) == 0);
+    }
+    int maxArcId() const {
+      return (Parent::maxEdgeId() << 1) + 1;
+    }
+
+    bool direction(const Arc& arc) const {
+      return arc.forward;
+    }
+
+    Arc direct(const Edge& arc, bool dir) const {
+      return Arc(arc, dir);
+    }
+
+    int arcNum() const {
+      return 2 * Parent::edgeNum();
+    }
+
+    int edgeNum() const {
+      return Parent::edgeNum();
+    }
+
+
+  };
+}
+
+#endif
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 732)
+++ lemon/bits/edge_set_extender.h	(revision 664)
@@ -538,5 +538,5 @@
 
     public:
-      explicit ArcMap(const Graph& _g) 
+      ArcMap(const Graph& _g) 
 	: Parent(_g) {}
       ArcMap(const Graph& _g, const _Value& _v) 
@@ -562,5 +562,5 @@
 
     public:
-      explicit EdgeMap(const Graph& _g) 
+      EdgeMap(const Graph& _g) 
 	: Parent(_g) {}
 
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 825)
+++ lemon/bits/graph_extender.h	(revision 664)
@@ -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);
     }
@@ -605,5 +605,5 @@
 
     public:
-      explicit NodeMap(const Graph& graph)
+      NodeMap(const Graph& graph)
         : Parent(graph) {}
       NodeMap(const Graph& graph, const _Value& value)
@@ -629,5 +629,5 @@
 
     public:
-      explicit ArcMap(const Graph& graph)
+      ArcMap(const Graph& graph)
         : Parent(graph) {}
       ArcMap(const Graph& graph, const _Value& value)
@@ -653,5 +653,5 @@
 
     public:
-      explicit EdgeMap(const Graph& graph)
+      EdgeMap(const Graph& graph)
         : Parent(graph) {}
 
Index: lemon/bits/map_extender.h
===================================================================
--- lemon/bits/map_extender.h	(revision 765)
+++ lemon/bits/map_extender.h	(revision 664)
@@ -50,6 +50,4 @@
     typedef typename Parent::ConstReference ConstReference;
 
-    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
-
     class MapIt;
     class ConstMapIt;
@@ -194,6 +192,4 @@
     typedef typename Parent::ConstReference ConstReference;
 
-    typedef typename Parent::ReferenceMapTag ReferenceMapTag;
-
     class MapIt;
     class ConstMapIt;
Index: lemon/bucket_heap.h
===================================================================
--- lemon/bucket_heap.h	(revision 758)
+++ 	(revision )
@@ -1,594 +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_BUCKET_HEAP_H
-#define LEMON_BUCKET_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Bucket heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  namespace _bucket_heap_bits {
-
-    template <bool MIN>
-    struct DirectionTraits {
-      static bool less(int left, int right) {
-        return left < right;
-      }
-      static void increase(int& value) {
-        ++value;
-      }
-    };
-
-    template <>
-    struct DirectionTraits<false> {
-      static bool less(int left, int right) {
-        return left > right;
-      }
-      static void increase(int& value) {
-        --value;
-      }
-    };
-
-  }
-
-  /// \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
-  template <typename IM, bool MIN = true>
-  class BucketHeap {
-
-  public:
-
-    /// Type of the item-int map.
-    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:
-
-    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;
-
-  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
-    /// 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.
-    };
-
-  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 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.
-    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(); _first.clear(); _minimum = 0;
-    }
-
-  private:
-
-    void relocateLast(int idx) {
-      if (idx + 1 < int(_data.size())) {
-        _data[idx] = _data.back();
-        if (_data[idx].prev != -1) {
-          _data[_data[idx].prev].next = idx;
-        } else {
-          _first[_data[idx].value] = idx;
-        }
-        if (_data[idx].next != -1) {
-          _data[_data[idx].next].prev = idx;
-        }
-        _iim[_data[idx].item] = idx;
-      }
-      _data.pop_back();
-    }
-
-    void unlace(int idx) {
-      if (_data[idx].prev != -1) {
-        _data[_data[idx].prev].next = _data[idx].next;
-      } else {
-        _first[_data[idx].value] = _data[idx].next;
-      }
-      if (_data[idx].next != -1) {
-        _data[_data[idx].next].prev = _data[idx].prev;
-      }
-    }
-
-    void lace(int idx) {
-      if (int(_first.size()) <= _data[idx].value) {
-        _first.resize(_data[idx].value + 1, -1);
-      }
-      _data[idx].next = _first[_data[idx].value];
-      if (_data[idx].next != -1) {
-        _data[_data[idx].next].prev = idx;
-      }
-      _first[_data[idx].value] = idx;
-      _data[idx].prev = -1;
-    }
-
-  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) {
-      push(p.first, p.second);
-    }
-
-    /// \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) {
-      int idx = _data.size();
-      _iim[i] = idx;
-      _data.push_back(BucketItem(i, p));
-      lace(idx);
-      if (Direction::less(p, _minimum)) {
-        _minimum = 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 {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _data[_first[_minimum]].item;
-    }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _minimum;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      int idx = _first[_minimum];
-      _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.
-    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.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].value;
-    }
-
-    /// \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 (Direction::less(p, _data[idx].value)) {
-        decrease(i, p);
-      } else {
-        increase(i, p);
-      }
-    }
-
-    /// \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];
-      unlace(idx);
-      _data[idx].value = p;
-      if (Direction::less(p, _minimum)) {
-        _minimum = p;
-      }
-      lace(idx);
-    }
-
-    /// \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];
-      unlace(idx);
-      _data[idx].value = p;
-      lace(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.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int idx = _iim[i];
-      if (idx >= 0) idx = 0;
-      return State(idx);
-    }
-
-    /// \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:
-
-    struct BucketItem {
-      BucketItem(const Item& _item, int _value)
-        : item(_item), value(_value) {}
-
-      Item item;
-      int value;
-
-      int prev, next;
-    };
-
-    ItemIntMap& _iim;
-    std::vector<int> _first;
-    std::vector<BucketItem> _data;
-    mutable int _minimum;
-
-  }; // class BucketHeap
-
-  /// \ingroup heaps
-  ///
-  /// \brief Simplified bucket heap data structure.
-  ///
-  /// 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.
-  ///
-  /// \sa BucketHeap
-  template <typename IM, bool MIN = true >
-  class SimpleBucketHeap {
-
-  public:
-
-    /// Type of the item-int map.
-    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:
-
-    typedef _bucket_heap_bits::DirectionTraits<MIN> Direction;
-
-  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
-    /// 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.
-    };
-
-  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 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.
-    int size() const { return _num; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    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.
-    void clear() {
-      _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
-    }
-
-    /// \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) {
-      push(p.first, p.second);
-    }
-
-    /// \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) {
-      int idx;
-      if (_free == -1) {
-        idx = _data.size();
-        _data.push_back(BucketItem(i));
-      } else {
-        idx = _free;
-        _free = _data[idx].next;
-        _data[idx].item = i;
-      }
-      _iim[i] = idx;
-      if (p >= int(_first.size())) _first.resize(p + 1, -1);
-      _data[idx].next = _first[p];
-      _first[p] = idx;
-      if (Direction::less(p, _minimum)) {
-        _minimum = p;
-      }
-      ++_num;
-    }
-
-    /// \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 {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _data[_first[_minimum]].item;
-    }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      return _minimum;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      while (_first[_minimum] == -1) {
-        Direction::increase(_minimum);
-      }
-      int idx = _first[_minimum];
-      _iim[_data[idx].item] = -2;
-      _first[_minimum] = _data[idx].next;
-      _data[idx].next = _free;
-      _free = idx;
-      --_num;
-    }
-
-    /// \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.
-    Prio operator[](const Item &i) const {
-      for (int k = 0; k < int(_first.size()); ++k) {
-        int idx = _first[k];
-        while (idx != -1) {
-          if (_data[idx].item == i) {
-            return k;
-          }
-          idx = _data[idx].next;
-        }
-      }
-      return -1;
-    }
-
-    /// \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 idx = _iim[i];
-      if (idx >= 0) idx = 0;
-      return State(idx);
-    }
-
-  private:
-
-    struct BucketItem {
-      BucketItem(const Item& _item)
-        : item(_item) {}
-
-      Item item;
-      int next;
-    };
-
-    ItemIntMap& _iim;
-    std::vector<int> _first;
-    std::vector<BucketItem> _data;
-    int _free, _num;
-    mutable int _minimum;
-
-  }; // class SimpleBucketHeap
-
-}
-
-#endif
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 793)
+++ lemon/cbc.cc	(revision 623)
@@ -95,16 +95,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 793)
+++ lemon/cbc.h	(revision 623)
@@ -63,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);
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 833)
+++ lemon/circulation.h	(revision 688)
@@ -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.
@@ -307,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().
@@ -458,9 +451,8 @@
     }
 
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    Circulation& tolerance(const Tolerance& tolerance) {
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
+    Circulation& tolerance(const Tolerance& tolerance) const {
       _tol = tolerance;
       return *this;
@@ -469,14 +461,13 @@
     /// \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;
+      return tolerance;
     }
 
     /// \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 793)
+++ lemon/clp.cc	(revision 623)
@@ -79,17 +79,4 @@
   }
 
-  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;
-  }
-
 
   void ClpLp::_eraseCol(int c) {
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 793)
+++ lemon/clp.h	(revision 623)
@@ -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);
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 833)
+++ lemon/concepts/digraph.h	(revision 627)
@@ -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) { 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,44 +393,43 @@
       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 incomming 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 incomming 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) { }
 
@@ -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 833)
+++ lemon/concepts/graph.h	(revision 627)
@@ -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 DigraphCopy instead.
-      Graph(const Graph&) {}
-      /// \brief Assignment of a graph to another one is \e not allowed.
-      /// Use DigraphCopy 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.
-      class Arc {
-      public:
-        /// Default constructor
-
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+      /// The directed arc type.
+
+      /// The directed arc type. It can be converted to the
+      /// edge or it should be inherited from the undirected
+      /// arc.
+      class Arc : public Edge {
+      public:
+        /// Default constructor
+
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -333,46 +323,40 @@
         /// Copy constructor.
         ///
-        Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        Arc(const Arc& e) : Edge(e) { }
+        /// 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.
-        ///
-        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 +364,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 +372,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) { 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 +418,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);
         }
-        /// 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 +446,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 +470,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);
         }
-        /// 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 +506,7 @@
       public:
 
-        /// Constructor
-        explicit NodeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Graph&) { }
+        ///\e
         NodeMap(const Graph&, T) { }
 
@@ -532,8 +523,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 +531,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 +547,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 +555,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 +571,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 +704,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 incomming 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 incomming 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 833)
+++ lemon/concepts/graph_components.h	(revision 664)
@@ -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
@@ -72,9 +72,4 @@
       GraphItem& operator=(const GraphItem&) { return *this; }
 
-      /// \brief Assignment operator for INVALID.
-      ///
-      /// This operator makes the item invalid.
-      GraphItem& operator=(Invalid) { return *this; }
-
       /// \brief Equality operator.
       ///
@@ -93,5 +88,5 @@
       /// 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.
@@ -102,5 +97,4 @@
         void constraints() {
           _GraphItem i1;
-          i1=INVALID;
           _GraphItem i2 = i1;
           _GraphItem i3 = INVALID;
@@ -228,5 +222,12 @@
         /// be convertible to the represented edge.
         Edge(const Arc&) {}
-     };
+
+        /// \brief Assign an arc to an edge.
+        ///
+        /// This function assigns an arc to an edge.
+        /// Besides the core graph item functionality each arc should
+        /// be convertible to the represented edge.
+        Edge& operator=(const Arc&) { return *this; }
+      };
 
       /// \brief Return one end node of an edge.
@@ -353,10 +354,8 @@
           checkConcept<Base, _Digraph >();
           typename _Digraph::Node node;
-          node=INVALID;
           int nid = digraph.id(node);
           nid = digraph.id(node);
           node = digraph.nodeFromId(nid);
           typename _Digraph::Arc arc;
-          arc=INVALID;
           int eid = digraph.id(arc);
           eid = digraph.id(arc);
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 757)
+++ lemon/concepts/heap.h	(revision 631)
@@ -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,58 +73,42 @@
       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.
+      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
       explicit Heap(ItemIntMap &map) {}
 
-      /// \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.
-      explicit Heap(ItemIntMap &map, const CMP &comp) {}
-
       /// \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.
       void push(const Item &i, const Prio &p) {}
 
-      /// \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 {}
@@ -137,35 +116,33 @@
       /// \brief The minimum priority.
       ///
-      /// This function returns the minimum priority.
+      /// Returns the minimum priority.
       /// \pre The heap must be non-empty.
       Prio prio() const {}
 
-      /// \brief Remove the item having minimum priority.
-      ///
-      /// This function removes the item having minimum priority.
+      /// \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.
       void erase(const Item &i) {}
 
-      /// \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 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 {}
 
-      /// \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.
@@ -173,21 +150,22 @@
       void set(const Item &i, const Prio &p) {}
 
-      /// \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.
+      /// \pre \c i must be stored in the heap with priority at least \c p.
       void decrease(const Item &i, const Prio &p) {}
 
-      /// \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.
+      /// \pre \c i must be stored in the heap with priority at most \c p.
       void increase(const Item &i, const Prio &p) {}
 
-      /// \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
@@ -199,9 +177,9 @@
       State state(const Item &i) const {}
 
-      /// \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.
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 765)
+++ lemon/concepts/maps.h	(revision 576)
@@ -183,6 +183,5 @@
       template<typename _ReferenceMap>
       struct Constraints {
-        typename enable_if<typename _ReferenceMap::ReferenceMapTag, void>::type
-        constraints() {
+        void constraints() {
           checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
           ref = m[key];
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 832)
+++ lemon/concepts/path.h	(revision 606)
@@ -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,9 +60,9 @@
       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) {
@@ -80,5 +71,5 @@
       }
 
-      /// 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; }
 
@@ -202,16 +193,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 {
@@ -223,5 +220,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;}
 
@@ -231,12 +228,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:
@@ -245,8 +243,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; }
 
@@ -263,9 +261,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:
@@ -274,8 +271,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 674)
@@ -1,3 +1,2 @@
-#define LEMON_VERSION "@PROJECT_VERSION@"
 #cmakedefine LEMON_HAVE_LONG_LONG 1
 #cmakedefine LEMON_HAVE_LP 1
Index: lemon/config.h.in
===================================================================
--- lemon/config.h.in	(revision 725)
+++ lemon/config.h.in	(revision 674)
@@ -1,5 +1,2 @@
-/* The version string */
-#undef LEMON_VERSION
-
 /* Define to 1 if you have long long */
 #undef LEMON_HAVE_LONG_LONG
Index: lemon/connectivity.h
===================================================================
--- lemon/connectivity.h	(revision 695)
+++ lemon/connectivity.h	(revision 633)
@@ -43,14 +43,10 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether an undirected graph is connected.
-  ///
-  /// This function checks whether the given undirected graph is connected,
-  /// i.e. there is a path between any two nodes in the graph.
-  ///
-  /// \return \c true if the graph is connected.
+  /// \brief Check whether the given undirected graph is connected.
+  ///
+  /// Check whether the given undirected graph is connected.
+  /// \param graph The undirected graph.
+  /// \return \c true when there is path between any two nodes in the graph.
   /// \note By definition, the empty graph is connected.
-  ///
-  /// \see countConnectedComponents(), connectedComponents()
-  /// \see stronglyConnected()
   template <typename Graph>
   bool connected(const Graph& graph) {
@@ -72,16 +68,10 @@
   /// \brief Count the number of connected components of an undirected graph
   ///
-  /// This function counts the number of connected components of the given
-  /// undirected graph.
-  ///
-  /// The connected components are the classes of an equivalence relation
-  /// on the nodes of an undirected graph. Two nodes are in the same class
-  /// if they are connected with a path.
-  ///
-  /// \return The number of connected components.
+  /// Count the number of connected components of an undirected graph
+  ///
+  /// \param graph The graph. It must be undirected.
+  /// \return The number of components
   /// \note By definition, the empty graph consists
   /// of zero connected components.
-  ///
-  /// \see connected(), connectedComponents()
   template <typename Graph>
   int countConnectedComponents(const Graph &graph) {
@@ -120,24 +110,15 @@
   /// \brief Find the connected components of an undirected graph
   ///
-  /// This function finds the connected components of the given undirected
-  /// graph.
-  ///
-  /// The connected components are the classes of an equivalence relation
-  /// on the nodes of an undirected graph. Two nodes are in the same class
-  /// if they are connected with a path.
+  /// Find the connected components of an undirected graph.
   ///
   /// \image html connected_components.png
   /// \image latex connected_components.eps "Connected components" width=\textwidth
   ///
-  /// \param graph The undirected graph.
+  /// \param graph The graph. It must be undirected.
   /// \retval compMap A writable node map. The values will be set from 0 to
-  /// the number of the connected components minus one. Each value of the map
-  /// will be set exactly once, and the values of a certain component will be
+  /// the number of the connected components minus one. Each values of the map
+  /// will be set exactly once, the values of a certain component will be
   /// set continuously.
-  /// \return The number of connected components.
-  /// \note By definition, the empty graph consists
-  /// of zero connected components.
-  ///
-  /// \see connected(), countConnectedComponents()
+  /// \return The number of components
   template <class Graph, class NodeMap>
   int connectedComponents(const Graph &graph, NodeMap &compMap) {
@@ -251,15 +232,13 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether a directed graph is strongly connected.
-  ///
-  /// This function checks whether the given directed graph is strongly
-  /// connected, i.e. any two nodes of the digraph are
+  /// \brief Check whether the given directed graph is strongly connected.
+  ///
+  /// Check whether the given directed graph is strongly connected. The
+  /// graph is strongly connected when any two nodes of the graph are
   /// connected with directed paths in both direction.
-  ///
-  /// \return \c true if the digraph is strongly connected.
-  /// \note By definition, the empty digraph is strongly connected.
-  /// 
-  /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
-  /// \see connected()
+  /// \return \c false when the graph is not strongly connected.
+  /// \see connected
+  ///
+  /// \note By definition, the empty graph is strongly connected.
   template <typename Digraph>
   bool stronglyConnected(const Digraph& digraph) {
@@ -292,5 +271,5 @@
     RDigraph rdigraph(digraph);
 
-    typedef DfsVisitor<RDigraph> RVisitor;
+    typedef DfsVisitor<Digraph> RVisitor;
     RVisitor rvisitor;
 
@@ -311,20 +290,16 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of strongly connected components of a 
-  /// directed graph
-  ///
-  /// This function counts the number of strongly connected components of
-  /// the given directed graph.
-  ///
+  /// \brief Count the strongly connected components of a directed graph
+  ///
+  /// Count the strongly connected components of a directed graph.
   /// The strongly connected components are the classes of an
-  /// equivalence relation on the nodes of a digraph. Two nodes are in
+  /// equivalence relation on the nodes of the graph. Two nodes are in
   /// the same class if they are connected with directed paths in both
   /// direction.
   ///
-  /// \return The number of strongly connected components.
-  /// \note By definition, the empty digraph has zero
+  /// \param digraph The graph.
+  /// \return The number of components
+  /// \note By definition, the empty graph has zero
   /// strongly connected components.
-  ///
-  /// \see stronglyConnected(), stronglyConnectedComponents()
   template <typename Digraph>
   int countStronglyConnectedComponents(const Digraph& digraph) {
@@ -381,13 +356,11 @@
   /// \brief Find the strongly connected components of a directed graph
   ///
-  /// This function finds the strongly connected components of the given
-  /// directed graph. In addition, the numbering of the components will
-  /// satisfy that there is no arc going from a higher numbered component
-  /// to a lower one (i.e. it provides a topological order of the components).
-  ///
-  /// The strongly connected components are the classes of an
-  /// equivalence relation on the nodes of a digraph. Two nodes are in
-  /// the same class if they are connected with directed paths in both
-  /// direction.
+  /// Find the strongly connected components of a directed graph.  The
+  /// strongly connected components are the classes of an equivalence
+  /// relation on the nodes of the graph. Two nodes are in
+  /// relationship when there are directed paths between them in both
+  /// direction. In addition, the numbering of components will satisfy
+  /// that there is no arc going from a higher numbered component to
+  /// a lower.
   ///
   /// \image html strongly_connected_components.png
@@ -397,11 +370,7 @@
   /// \retval compMap A writable node map. The values will be set from 0 to
   /// the number of the strongly connected components minus one. Each value
-  /// of the map will be set exactly once, and the values of a certain
-  /// component will be set continuously.
-  /// \return The number of strongly connected components.
-  /// \note By definition, the empty digraph has zero
-  /// strongly connected components.
-  ///
-  /// \see stronglyConnected(), countStronglyConnectedComponents()
+  /// of the map will be set exactly once, the values of a certain component
+  /// will be set continuously.
+  /// \return The number of components
   template <typename Digraph, typename NodeMap>
   int stronglyConnectedComponents(const Digraph& digraph, NodeMap& compMap) {
@@ -456,22 +425,17 @@
   /// \brief Find the cut arcs of the strongly connected components.
   ///
-  /// This function finds the cut arcs of the strongly connected components
-  /// of the given digraph.
-  ///
-  /// The strongly connected components are the classes of an
-  /// equivalence relation on the nodes of a digraph. Two nodes are in
-  /// the same class if they are connected with directed paths in both
-  /// direction.
+  /// Find the cut arcs of the strongly connected components.
+  /// The strongly connected components are the classes of an equivalence
+  /// relation on the nodes of the graph. Two nodes are in relationship
+  /// when there are directed paths between them in both direction.
   /// The strongly connected components are separated by the cut arcs.
   ///
-  /// \param digraph The digraph.
-  /// \retval cutMap A writable arc map. The values will be set to \c true
-  /// for the cut arcs (exactly once for each cut arc), and will not be
-  /// changed for other arcs.
-  /// \return The number of cut arcs.
-  ///
-  /// \see stronglyConnected(), stronglyConnectedComponents()
+  /// \param graph The graph.
+  /// \retval cutMap A writable node map. The values will be set true when the
+  /// arc is a cut arc.
+  ///
+  /// \return The number of cut arcs
   template <typename Digraph, typename ArcMap>
-  int stronglyConnectedCutArcs(const Digraph& digraph, ArcMap& cutMap) {
+  int stronglyConnectedCutArcs(const Digraph& graph, ArcMap& cutMap) {
     checkConcept<concepts::Digraph, Digraph>();
     typedef typename Digraph::Node Node;
@@ -485,11 +449,11 @@
     typedef typename Container::iterator Iterator;
 
-    Container nodes(countNodes(digraph));
+    Container nodes(countNodes(graph));
     typedef LeaveOrderVisitor<Digraph, Iterator> Visitor;
     Visitor visitor(nodes.begin());
 
-    DfsVisit<Digraph, Visitor> dfs(digraph, visitor);
+    DfsVisit<Digraph, Visitor> dfs(graph, visitor);
     dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
+    for (NodeIt it(graph); it != INVALID; ++it) {
       if (!dfs.reached(it)) {
         dfs.addSource(it);
@@ -501,12 +465,12 @@
     typedef ReverseDigraph<const Digraph> RDigraph;
 
-    RDigraph rdigraph(digraph);
+    RDigraph rgraph(graph);
 
     int cutNum = 0;
 
     typedef StronglyConnectedCutArcsVisitor<RDigraph, ArcMap> RVisitor;
-    RVisitor rvisitor(rdigraph, cutMap, cutNum);
-
-    DfsVisit<RDigraph, RVisitor> rdfs(rdigraph, rvisitor);
+    RVisitor rvisitor(rgraph, cutMap, cutNum);
+
+    DfsVisit<RDigraph, RVisitor> rdfs(rgraph, rvisitor);
 
     rdfs.init();
@@ -743,13 +707,12 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether an undirected graph is bi-node-connected.
-  ///
-  /// This function checks whether the given undirected graph is 
-  /// bi-node-connected, i.e. any two edges are on same circle.
-  ///
-  /// \return \c true if the graph bi-node-connected.
-  /// \note By definition, the empty graph is bi-node-connected.
-  ///
-  /// \see countBiNodeConnectedComponents(), biNodeConnectedComponents()
+  /// \brief Checks the graph is bi-node-connected.
+  ///
+  /// This function checks that the undirected graph is bi-node-connected
+  /// graph. The graph is bi-node-connected if any two undirected edge is
+  /// on same circle.
+  ///
+  /// \param graph The graph.
+  /// \return \c true when the graph bi-node-connected.
   template <typename Graph>
   bool biNodeConnected(const Graph& graph) {
@@ -759,17 +722,13 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of bi-node-connected components of an 
-  /// undirected graph.
-  ///
-  /// This function counts the number of bi-node-connected components of
-  /// the given undirected graph.
-  ///
-  /// The bi-node-connected components are the classes of an equivalence
-  /// relation on the edges of a undirected graph. Two edges are in the
-  /// same class if they are on same circle.
-  ///
-  /// \return The number of bi-node-connected components.
-  ///
-  /// \see biNodeConnected(), biNodeConnectedComponents()
+  /// \brief Count the biconnected components.
+  ///
+  /// This function finds the bi-node-connected components in an undirected
+  /// graph. The biconnected components are the classes of an equivalence
+  /// relation on the undirected edges. Two undirected edge is in relationship
+  /// when they are on same circle.
+  ///
+  /// \param graph The graph.
+  /// \return The number of components.
   template <typename Graph>
   int countBiNodeConnectedComponents(const Graph& graph) {
@@ -798,24 +757,20 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Find the bi-node-connected components of an undirected graph.
-  ///
-  /// This function finds the bi-node-connected components of the given
-  /// undirected graph.
-  ///
-  /// The bi-node-connected components are the classes of an equivalence
-  /// relation on the edges of a undirected graph. Two edges are in the
-  /// same class if they are on same circle.
+  /// \brief Find the bi-node-connected components.
+  ///
+  /// This function finds the bi-node-connected components in an undirected
+  /// graph. The bi-node-connected components are the classes of an equivalence
+  /// relation on the undirected edges. Two undirected edge are in relationship
+  /// when they are on same circle.
   ///
   /// \image html node_biconnected_components.png
   /// \image latex node_biconnected_components.eps "bi-node-connected components" width=\textwidth
   ///
-  /// \param graph The undirected graph.
-  /// \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 
-  /// certain component will be set continuously.
-  /// \return The number of bi-node-connected components.
-  ///
-  /// \see biNodeConnected(), countBiNodeConnectedComponents()
+  /// \param graph The graph.
+  /// \retval compMap A writable uedge map. The values will be set from 0
+  /// to the number of the biconnected components minus one. Each values
+  /// of the map will be set exactly once, the values of a certain component
+  /// will be set continuously.
+  /// \return The number of components.
   template <typename Graph, typename EdgeMap>
   int biNodeConnectedComponents(const Graph& graph,
@@ -847,23 +802,16 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Find the bi-node-connected cut nodes in an undirected graph.
-  ///
-  /// This function finds the bi-node-connected cut nodes in the given
-  /// undirected graph.
-  ///
-  /// The bi-node-connected components are the classes of an equivalence
-  /// relation on the edges of a undirected graph. Two edges are in the
-  /// same class if they are on same circle.
-  /// The bi-node-connected components are separted by the cut nodes of
-  /// the components.
-  ///
-  /// \param graph The undirected graph.
-  /// \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
-  /// other nodes.
+  /// \brief Find the bi-node-connected cut nodes.
+  ///
+  /// This function finds the bi-node-connected cut nodes in an undirected
+  /// graph. The bi-node-connected components are the classes of an equivalence
+  /// relation on the undirected edges. Two undirected edges are in
+  /// relationship when they are on same circle. The biconnected components
+  /// are separted by nodes which are the cut nodes of the components.
+  ///
+  /// \param graph The graph.
+  /// \retval cutMap A writable edge map. The values will be set true when
+  /// the node separate two or more components.
   /// \return The number of the cut nodes.
-  ///
-  /// \see biNodeConnected(), biNodeConnectedComponents()
   template <typename Graph, typename NodeMap>
   int biNodeConnectedCutNodes(const Graph& graph, NodeMap& cutMap) {
@@ -1084,14 +1032,12 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether an undirected graph is bi-edge-connected.
-  ///
-  /// 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.
-  ///
-  /// \return \c true if the graph is bi-edge-connected.
-  /// \note By definition, the empty graph is bi-edge-connected.
-  ///
-  /// \see countBiEdgeConnectedComponents(), biEdgeConnectedComponents()
+  /// \brief Checks that the graph is bi-edge-connected.
+  ///
+  /// This function checks that the graph is bi-edge-connected. The undirected
+  /// graph is bi-edge-connected when any two nodes are connected with two
+  /// edge-disjoint paths.
+  ///
+  /// \param graph The undirected graph.
+  /// \return The number of components.
   template <typename Graph>
   bool biEdgeConnected(const Graph& graph) {
@@ -1101,18 +1047,13 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of bi-edge-connected components of an
-  /// undirected graph.
-  ///
-  /// This function counts the number of bi-edge-connected components of
-  /// the given undirected graph.
-  ///
-  /// The bi-edge-connected components are the classes of an equivalence
-  /// relation on the nodes of an undirected graph. Two nodes are in the
-  /// same class if they are connected with at least two edge-disjoint
-  /// paths.
-  ///
-  /// \return The number of bi-edge-connected components.
-  ///
-  /// \see biEdgeConnected(), biEdgeConnectedComponents()
+  /// \brief Count the bi-edge-connected components.
+  ///
+  /// This function count the bi-edge-connected components in an undirected
+  /// graph. The bi-edge-connected components are the classes of an equivalence
+  /// relation on the nodes. Two nodes are in relationship when they are
+  /// connected with at least two edge-disjoint paths.
+  ///
+  /// \param graph The undirected graph.
+  /// \return The number of components.
   template <typename Graph>
   int countBiEdgeConnectedComponents(const Graph& graph) {
@@ -1141,25 +1082,20 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Find the bi-edge-connected components of an undirected graph.
-  ///
-  /// This function finds the bi-edge-connected components of the given
-  /// undirected graph.
-  ///
-  /// The bi-edge-connected components are the classes of an equivalence
-  /// relation on the nodes of an undirected graph. Two nodes are in the
-  /// same class if they are connected with at least two edge-disjoint
-  /// paths.
+  /// \brief Find the bi-edge-connected components.
+  ///
+  /// This function finds the bi-edge-connected components in an undirected
+  /// graph. The bi-edge-connected components are the classes of an equivalence
+  /// relation on the nodes. Two nodes are in relationship when they are
+  /// connected at least two edge-disjoint paths.
   ///
   /// \image html edge_biconnected_components.png
   /// \image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
   ///
-  /// \param graph The undirected graph.
+  /// \param graph The graph.
   /// \retval compMap A writable node map. The values will be set from 0 to
-  /// the number of the bi-edge-connected components minus one. Each 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-edge-connected components.
-  ///
-  /// \see biEdgeConnected(), countBiEdgeConnectedComponents()
+  /// the number of the biconnected components minus one. Each values
+  /// of the map will be set exactly once, the values of a certain component
+  /// will be set continuously.
+  /// \return The number of components.
   template <typename Graph, typename NodeMap>
   int biEdgeConnectedComponents(const Graph& graph, NodeMap& compMap) {
@@ -1190,23 +1126,17 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Find the bi-edge-connected cut edges in an undirected graph.
-  ///
-  /// This function finds the bi-edge-connected cut edges in the given
-  /// undirected graph. 
-  ///
-  /// The bi-edge-connected components are the classes of an equivalence
-  /// relation on the nodes of an undirected graph. Two nodes are in the
-  /// same class if they are connected with at least two edge-disjoint
-  /// paths.
-  /// The bi-edge-connected components are separted by the cut edges of
-  /// the components.
-  ///
-  /// \param graph The undirected graph.
-  /// \retval cutMap A writable edge map. The values will be set to \c true
-  /// for the cut edges (exactly once for each cut edge), and will not be
-  /// changed for other edges.
+  /// \brief Find the bi-edge-connected cut edges.
+  ///
+  /// This function finds the bi-edge-connected components in an undirected
+  /// graph. The bi-edge-connected components are the classes of an equivalence
+  /// relation on the nodes. Two nodes are in relationship when they are
+  /// connected with at least two edge-disjoint paths. The bi-edge-connected
+  /// components are separted by edges which are the cut edges of the
+  /// components.
+  ///
+  /// \param graph The graph.
+  /// \retval cutMap A writable node map. The values will be set true when the
+  /// edge is a cut edge.
   /// \return The number of cut edges.
-  ///
-  /// \see biEdgeConnected(), biEdgeConnectedComponents()
   template <typename Graph, typename EdgeMap>
   int biEdgeConnectedCutEdges(const Graph& graph, EdgeMap& cutMap) {
@@ -1260,14 +1190,21 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether a digraph is DAG.
-  ///
-  /// This function checks whether the given digraph is DAG, i.e.
-  /// \e Directed \e Acyclic \e Graph.
-  /// \return \c true if there is no directed cycle in the digraph.
-  /// \see acyclic()
-  template <typename Digraph>
-  bool dag(const Digraph& digraph) {
+  /// \brief Sort the nodes of a DAG into topolgical order.
+  ///
+  /// Sort the nodes of a DAG into topolgical order.
+  ///
+  /// \param graph The graph. It must be directed and acyclic.
+  /// \retval order A writable node map. The values will be set from 0 to
+  /// the number of the nodes in the graph minus one. Each values of the map
+  /// will be set exactly once, the values  will be set descending order.
+  ///
+  /// \see checkedTopologicalSort
+  /// \see dag
+  template <typename Digraph, typename NodeMap>
+  void topologicalSort(const Digraph& graph, NodeMap& order) {
+    using namespace _connectivity_bits;
 
     checkConcept<concepts::Digraph, Digraph>();
+    checkConcept<concepts::WriteMap<typename Digraph::Node, int>, NodeMap>();
 
     typedef typename Digraph::Node Node;
@@ -1275,62 +1212,12 @@
     typedef typename Digraph::Arc Arc;
 
-    typedef typename Digraph::template NodeMap<bool> ProcessedMap;
-
-    typename Dfs<Digraph>::template SetProcessedMap<ProcessedMap>::
-      Create dfs(digraph);
-
-    ProcessedMap processed(digraph);
-    dfs.processedMap(processed);
+    TopologicalSortVisitor<Digraph, NodeMap>
+      visitor(order, countNodes(graph));
+
+    DfsVisit<Digraph, TopologicalSortVisitor<Digraph, NodeMap> >
+      dfs(graph, visitor);
 
     dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
-      if (!dfs.reached(it)) {
-        dfs.addSource(it);
-        while (!dfs.emptyQueue()) {
-          Arc arc = dfs.nextArc();
-          Node target = digraph.target(arc);
-          if (dfs.reached(target) && !processed[target]) {
-            return false;
-          }
-          dfs.processNextArc();
-        }
-      }
-    }
-    return true;
-  }
-
-  /// \ingroup graph_properties
-  ///
-  /// \brief Sort the nodes of a DAG into topolgical order.
-  ///
-  /// This function sorts the nodes of the given acyclic digraph (DAG)
-  /// into topolgical order.
-  ///
-  /// \param digraph The digraph, which must be DAG.
-  /// \retval order A writable node map. The values will be 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.
-  ///
-  /// \see dag(), checkedTopologicalSort()
-  template <typename Digraph, typename NodeMap>
-  void topologicalSort(const Digraph& digraph, NodeMap& order) {
-    using namespace _connectivity_bits;
-
-    checkConcept<concepts::Digraph, Digraph>();
-    checkConcept<concepts::WriteMap<typename Digraph::Node, int>, NodeMap>();
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-
-    TopologicalSortVisitor<Digraph, NodeMap>
-      visitor(order, countNodes(digraph));
-
-    DfsVisit<Digraph, TopologicalSortVisitor<Digraph, NodeMap> >
-      dfs(digraph, visitor);
-
-    dfs.init();
-    for (NodeIt it(digraph); it != INVALID; ++it) {
+    for (NodeIt it(graph); it != INVALID; ++it) {
       if (!dfs.reached(it)) {
         dfs.addSource(it);
@@ -1344,16 +1231,16 @@
   /// \brief Sort the nodes of a DAG into topolgical order.
   ///
-  /// This function sorts the nodes of the given acyclic digraph (DAG)
-  /// into topolgical order and also checks whether the given digraph
-  /// is DAG.
-  ///
-  /// \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. 
-  /// Each value of the map will be set exactly once, and the values will
-  /// be set descending order.
-  /// \return \c false if the digraph is not DAG.
-  ///
-  /// \see dag(), topologicalSort()
+  /// Sort the nodes of a DAG into topolgical order. It also checks
+  /// that the given graph is DAG.
+  ///
+  /// \param digraph The graph. It must be directed and acyclic.
+  /// \retval order A readable - writable node map. The values will be set
+  /// from 0 to the number of the nodes in the graph minus one. Each values
+  /// of the map will be set exactly once, the values will be set descending
+  /// order.
+  /// \return \c false when the graph is not DAG.
+  ///
+  /// \see topologicalSort
+  /// \see dag
   template <typename Digraph, typename NodeMap>
   bool checkedTopologicalSort(const Digraph& digraph, NodeMap& order) {
@@ -1397,9 +1284,52 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether an undirected graph is acyclic.
-  ///
-  /// This function checks whether the given undirected graph is acyclic.
-  /// \return \c true if there is no cycle in the graph.
-  /// \see dag()
+  /// \brief Check that the given directed graph is a DAG.
+  ///
+  /// Check that the given directed graph is a DAG. The DAG is
+  /// an Directed Acyclic Digraph.
+  /// \return \c false when the graph is not DAG.
+  /// \see acyclic
+  template <typename Digraph>
+  bool dag(const Digraph& digraph) {
+
+    checkConcept<concepts::Digraph, Digraph>();
+
+    typedef typename Digraph::Node Node;
+    typedef typename Digraph::NodeIt NodeIt;
+    typedef typename Digraph::Arc Arc;
+
+    typedef typename Digraph::template NodeMap<bool> ProcessedMap;
+
+    typename Dfs<Digraph>::template SetProcessedMap<ProcessedMap>::
+      Create dfs(digraph);
+
+    ProcessedMap processed(digraph);
+    dfs.processedMap(processed);
+
+    dfs.init();
+    for (NodeIt it(digraph); it != INVALID; ++it) {
+      if (!dfs.reached(it)) {
+        dfs.addSource(it);
+        while (!dfs.emptyQueue()) {
+          Arc edge = dfs.nextArc();
+          Node target = digraph.target(edge);
+          if (dfs.reached(target) && !processed[target]) {
+            return false;
+          }
+          dfs.processNextArc();
+        }
+      }
+    }
+    return true;
+  }
+
+  /// \ingroup graph_properties
+  ///
+  /// \brief Check that the given undirected graph is acyclic.
+  ///
+  /// Check that the given undirected graph acyclic.
+  /// \param graph The undirected graph.
+  /// \return \c true when there is no circle in the graph.
+  /// \see dag
   template <typename Graph>
   bool acyclic(const Graph& graph) {
@@ -1414,9 +1344,9 @@
         dfs.addSource(it);
         while (!dfs.emptyQueue()) {
-          Arc arc = dfs.nextArc();
-          Node source = graph.source(arc);
-          Node target = graph.target(arc);
+          Arc edge = dfs.nextArc();
+          Node source = graph.source(edge);
+          Node target = graph.target(edge);
           if (dfs.reached(target) &&
-              dfs.predArc(source) != graph.oppositeArc(arc)) {
+              dfs.predArc(source) != graph.oppositeArc(edge)) {
             return false;
           }
@@ -1430,9 +1360,9 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether an undirected graph is tree.
-  ///
-  /// This function checks whether the given undirected graph is tree.
-  /// \return \c true if the graph is acyclic and connected.
-  /// \see acyclic(), connected()
+  /// \brief Check that the given undirected graph is tree.
+  ///
+  /// Check that the given undirected graph is tree.
+  /// \param graph The undirected graph.
+  /// \return \c true when the graph is acyclic and connected.
   template <typename Graph>
   bool tree(const Graph& graph) {
@@ -1441,14 +1371,13 @@
     typedef typename Graph::NodeIt NodeIt;
     typedef typename Graph::Arc Arc;
-    if (NodeIt(graph) == INVALID) return true;
     Dfs<Graph> dfs(graph);
     dfs.init();
     dfs.addSource(NodeIt(graph));
     while (!dfs.emptyQueue()) {
-      Arc arc = dfs.nextArc();
-      Node source = graph.source(arc);
-      Node target = graph.target(arc);
+      Arc edge = dfs.nextArc();
+      Node source = graph.source(edge);
+      Node target = graph.target(edge);
       if (dfs.reached(target) &&
-          dfs.predArc(source) != graph.oppositeArc(arc)) {
+          dfs.predArc(source) != graph.oppositeArc(edge)) {
         return false;
       }
@@ -1523,12 +1452,13 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Check whether an undirected graph is bipartite.
-  ///
-  /// The function checks whether the given undirected graph is bipartite.
-  /// \return \c true if the graph is bipartite.
-  ///
-  /// \see bipartitePartitions()
+  /// \brief Check if the given undirected graph is bipartite or not
+  ///
+  /// The function checks if the given undirected \c graph graph is bipartite
+  /// or not. The \ref Bfs algorithm is used to calculate the result.
+  /// \param graph The undirected graph.
+  /// \return \c true if \c graph is bipartite, \c false otherwise.
+  /// \sa bipartitePartitions
   template<typename Graph>
-  bool bipartite(const Graph &graph){
+  inline bool bipartite(const Graph &graph){
     using namespace _connectivity_bits;
 
@@ -1559,8 +1489,10 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Find the bipartite partitions of an undirected graph.
-  ///
-  /// This function checks whether the given undirected graph is bipartite
-  /// and gives back the bipartite partitions.
+  /// \brief Check if the given undirected graph is bipartite or not
+  ///
+  /// The function checks if the given undirected graph is bipartite
+  /// or not. The  \ref  Bfs  algorithm  is   used  to  calculate the result.
+  /// During the execution, the \c partMap will be set as the two
+  /// partitions of the graph.
   ///
   /// \image html bipartite_partitions.png
@@ -1568,16 +1500,12 @@
   ///
   /// \param graph The undirected graph.
-  /// \retval partMap A writable node map of \c bool (or convertible) value
-  /// type. The values will be set to \c true for one component and
-  /// \c false for the other one.
-  /// \return \c true if the graph is bipartite, \c false otherwise.
-  ///
-  /// \see bipartite()
+  /// \retval partMap A writable bool map of nodes. It will be set as the
+  /// two partitions of the graph.
+  /// \return \c true if \c graph is bipartite, \c false otherwise.
   template<typename Graph, typename NodeMap>
-  bool bipartitePartitions(const Graph &graph, NodeMap &partMap){
+  inline bool bipartitePartitions(const Graph &graph, NodeMap &partMap){
     using namespace _connectivity_bits;
 
     checkConcept<concepts::Graph, Graph>();
-    checkConcept<concepts::WriteMap<typename Graph::Node, bool>, NodeMap>();
 
     typedef typename Graph::Node Node;
@@ -1604,57 +1532,51 @@
   }
 
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether the given graph contains no loop arcs/edges.
-  ///
-  /// This function returns \c true if there are no loop arcs/edges in
-  /// the given graph. It works for both directed and undirected graphs.
-  template <typename Graph>
-  bool loopFree(const Graph& graph) {
-    for (typename Graph::ArcIt it(graph); it != INVALID; ++it) {
-      if (graph.source(it) == graph.target(it)) return false;
+  /// \brief Returns true when there are not loop edges in the graph.
+  ///
+  /// Returns true when there are not loop edges in the graph.
+  template <typename Digraph>
+  bool loopFree(const Digraph& digraph) {
+    for (typename Digraph::ArcIt it(digraph); it != INVALID; ++it) {
+      if (digraph.source(it) == digraph.target(it)) return false;
     }
     return true;
   }
 
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether the given graph contains no parallel arcs/edges.
-  ///
-  /// This function returns \c true if there are no parallel arcs/edges in
-  /// the given graph. It works for both directed and undirected graphs.
-  template <typename Graph>
-  bool parallelFree(const Graph& graph) {
-    typename Graph::template NodeMap<int> reached(graph, 0);
-    int cnt = 1;
-    for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-      for (typename Graph::OutArcIt a(graph, n); a != INVALID; ++a) {
-        if (reached[graph.target(a)] == cnt) return false;
-        reached[graph.target(a)] = cnt;
-      }
-      ++cnt;
+  /// \brief Returns true when there are not parallel edges in the graph.
+  ///
+  /// Returns true when there are not parallel edges in the graph.
+  template <typename Digraph>
+  bool parallelFree(const Digraph& digraph) {
+    typename Digraph::template NodeMap<bool> reached(digraph, false);
+    for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
+      for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) {
+        if (reached[digraph.target(a)]) return false;
+        reached.set(digraph.target(a), true);
+      }
+      for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) {
+        reached.set(digraph.target(a), false);
+      }
     }
     return true;
   }
 
-  /// \ingroup graph_properties
-  ///
-  /// \brief Check whether the given graph is simple.
-  ///
-  /// This function returns \c true if the given graph is simple, i.e.
-  /// it contains no loop arcs/edges and no parallel arcs/edges.
-  /// The function works for both directed and undirected graphs.
-  /// \see loopFree(), parallelFree()
-  template <typename Graph>
-  bool simpleGraph(const Graph& graph) {
-    typename Graph::template NodeMap<int> reached(graph, 0);
-    int cnt = 1;
-    for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-      reached[n] = cnt;
-      for (typename Graph::OutArcIt a(graph, n); a != INVALID; ++a) {
-        if (reached[graph.target(a)] == cnt) return false;
-        reached[graph.target(a)] = cnt;
-      }
-      ++cnt;
+  /// \brief Returns true when there are not loop edges and parallel
+  /// edges in the graph.
+  ///
+  /// Returns true when there are not loop edges and parallel edges in
+  /// the graph.
+  template <typename Digraph>
+  bool simpleDigraph(const Digraph& digraph) {
+    typename Digraph::template NodeMap<bool> reached(digraph, false);
+    for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
+      reached.set(n, true);
+      for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) {
+        if (reached[digraph.target(a)]) return false;
+        reached.set(digraph.target(a), true);
+      }
+      for (typename Digraph::OutArcIt a(digraph, n); a != INVALID; ++a) {
+        reached.set(digraph.target(a), false);
+      }
+      reached.set(n, false);
     }
     return true;
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 718)
+++ lemon/core.h	(revision 686)
@@ -27,14 +27,4 @@
 #include <lemon/bits/traits.h>
 #include <lemon/assert.h>
-
-// Disable the following warnings when compiling with MSVC:
-// C4250: 'class1' : inherits 'class2::member' via dominance
-// C4355: 'this' : used in base member initializer list
-// C4503: 'function' : decorated name length exceeded, name was truncated
-// C4800: 'type' : forcing value to bool 'true' or 'false' (performance warning)
-// C4996: 'function': was declared deprecated
-#ifdef _MSC_VER
-#pragma warning( disable : 4250 4355 4503 4800 4996 )
-#endif
 
 ///\file
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 793)
+++ lemon/cplex.cc	(revision 623)
@@ -112,37 +112,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) {
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 793)
+++ 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);
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 835)
+++ lemon/dfs.h	(revision 631)
@@ -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,5 +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.
@@ -98,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.
@@ -226,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> > {
@@ -246,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> > {
@@ -266,5 +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> > {
@@ -286,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> > {
@@ -413,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
@@ -634,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.
@@ -667,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).
@@ -677,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
@@ -688,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
@@ -696,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()
@@ -702,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()
@@ -731,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()
@@ -737,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).
@@ -763,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.
@@ -778,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.
@@ -798,5 +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.
@@ -813,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.
@@ -828,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;
   };
@@ -834,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>
@@ -863,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),
@@ -893,4 +900,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -900,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;
 
@@ -973,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()
     {
@@ -986,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)
@@ -1005,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)
@@ -1024,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)
@@ -1044,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)
@@ -1200,5 +1209,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;
 
@@ -1361,6 +1370,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
@@ -1575,6 +1584,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.
@@ -1608,5 +1621,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/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 835)
+++ lemon/dijkstra.h	(revision 631)
@@ -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
@@ -206,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;
@@ -309,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
@@ -330,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
@@ -351,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
@@ -427,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().
@@ -448,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
@@ -590,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.
@@ -807,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).
@@ -822,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
@@ -833,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
@@ -842,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()
@@ -848,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()
@@ -878,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()
@@ -884,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).
@@ -903,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.
     ///
@@ -932,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;
 
@@ -981,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.
@@ -996,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.
@@ -1016,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.
@@ -1031,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;
   };
@@ -1037,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,4 +1094,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -1105,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;
 
@@ -1182,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)
@@ -1201,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)
@@ -1221,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)
@@ -1239,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/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 834)
+++ lemon/edge_set.h	(revision 664)
@@ -23,5 +23,5 @@
 #include <lemon/bits/edge_set_extender.h>
 
-/// \ingroup graphs
+/// \ingroup semi_adaptors
 /// \file
 /// \brief ArcSet and EdgeSet classes.
@@ -85,10 +85,4 @@
     ListArcSetBase() : first_arc(-1), first_free_arc(-1) {}
 
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
-
     Arc addArc(const Node& u, const Node& v) {
       int n;
@@ -237,5 +231,5 @@
   };
 
-  /// \ingroup graphs
+  /// \ingroup semi_adaptors
   ///
   /// \brief Digraph using a node set of another digraph or graph and
@@ -256,12 +250,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> > {
@@ -423,10 +416,4 @@
 
     ListEdgeSetBase() : first_arc(-1), first_free_arc(-1) {}
-
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
 
     Edge addEdge(const Node& u, const Node& v) {
@@ -668,5 +655,5 @@
   };
 
-  /// \ingroup graphs
+  /// \ingroup semi_adaptors
   ///
   /// \brief Graph using a node set of another digraph or graph and an
@@ -687,11 +674,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>
@@ -831,10 +817,4 @@
     SmartArcSetBase() {}
 
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
-
     Arc addArc(const Node& u, const Node& v) {
       int n = arcs.size();
@@ -870,5 +850,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc.id;
     }
@@ -934,5 +914,5 @@
 
 
-  /// \ingroup graphs
+  /// \ingroup semi_adaptors
   ///
   /// \brief Digraph using a node set of another digraph or graph and
@@ -957,12 +937,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> > {
@@ -1134,10 +1113,4 @@
     SmartEdgeSetBase() {}
 
-    Node addNode() {
-      LEMON_ASSERT(false,
-        "This graph structure does not support node insertion");
-      return INVALID; // avoid warning
-    }
-
     Edge addEdge(const Node& u, const Node& v) {
       int n = arcs.size();
@@ -1177,5 +1150,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc.id;
     }
@@ -1185,5 +1158,5 @@
     }
 
-    static void next(Edge& arc) {
+    void next(Edge& arc) const {
       --arc.id;
     }
@@ -1285,5 +1258,5 @@
   };
 
-  /// \ingroup graphs
+  /// \ingroup semi_adaptors
   ///
   /// \brief Graph using a node set of another digraph or graph and an
@@ -1308,12 +1281,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/euler.h
===================================================================
--- lemon/euler.h	(revision 695)
+++ lemon/euler.h	(revision 639)
@@ -245,8 +245,8 @@
 
 
-  ///Check if the given graph is Eulerian
+  ///Check if the given graph is \e Eulerian
 
   /// \ingroup graph_properties
-  ///This function checks if the given graph is Eulerian.
+  ///This function checks if the given graph is \e Eulerian.
   ///It works for both directed and undirected graphs.
   ///
Index: lemon/fib_heap.h
===================================================================
--- lemon/fib_heap.h	(revision 758)
+++ 	(revision )
@@ -1,475 +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_FIB_HEAP_H
-#define LEMON_FIB_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Fibonacci heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-#include <lemon/math.h>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  /// \brief Fibonacci heap data structure.
-  ///
-  /// This class implements the \e Fibonacci \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
-  /// Fibonacci 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 FibHeap {
-  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;
-
-  private:
-    class Store;
-
-    std::vector<Store> _data;
-    int _minimum;
-    ItemIntMap &_iim;
-    Compare _comp;
-    int _num;
-
-  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
-    /// 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.
-    };
-
-    /// \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 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.
-    FibHeap(ItemIntMap &map, const Compare &comp)
-      : _minimum(0), _iim(map), _comp(comp), _num() {}
-
-    /// \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; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    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.
-    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) {
-      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].degree=0;
-        _data[i].in=true;
-        _data[i].marked=false;
-      }
-
-      if ( _num ) {
-        _data[_data[_minimum].right_neighbor].left_neighbor=i;
-        _data[i].right_neighbor=_data[_minimum].right_neighbor;
-        _data[_minimum].right_neighbor=i;
-        _data[i].left_neighbor=_minimum;
-        if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
-      } else {
-        _data[i].right_neighbor=_data[i].left_neighbor=i;
-        _minimum=i;
-      }
-      _data[i].prio=prio;
-      ++_num;
-    }
-
-    /// \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[_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.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      /*The first case is that there are only one root.*/
-      if ( _data[_minimum].left_neighbor==_minimum ) {
-        _data[_minimum].in=false;
-        if ( _data[_minimum].degree!=0 ) {
-          makeRoot(_data[_minimum].child);
-          _minimum=_data[_minimum].child;
-          balance();
-        }
-      } else {
-        int right=_data[_minimum].right_neighbor;
-        unlace(_minimum);
-        _data[_minimum].in=false;
-        if ( _data[_minimum].degree > 0 ) {
-          int left=_data[_minimum].left_neighbor;
-          int child=_data[_minimum].child;
-          int last_child=_data[child].left_neighbor;
-
-          makeRoot(child);
-
-          _data[left].right_neighbor=child;
-          _data[child].left_neighbor=left;
-          _data[right].left_neighbor=last_child;
-          _data[last_child].right_neighbor=right;
-        }
-        _minimum=right;
-        balance();
-      } // the case where there are more roots
-      --_num;
-    }
-
-    /// \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 ) {
-        if ( _data[i].parent!=-1 ) {
-          int p=_data[i].parent;
-          cut(i,p);
-          cascade(p);
-        }
-        _minimum=i;     //As if its prio would be -infinity
-        pop();
-      }
-    }
-
-    /// \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) {
-      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;
-      int p=_data[i].parent;
-
-      if ( p!=-1 && _comp(prio, _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) {
-      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.
-    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 balance() {
-
-      int maxdeg=int( std::floor( 2.08*log(double(_data.size()))))+1;
-
-      std::vector<int> A(maxdeg,-1);
-
-      /*
-       *Recall that now minimum does not point to the minimum prio element.
-       *We set minimum to this during balance().
-       */
-      int anchor=_data[_minimum].left_neighbor;
-      int next=_minimum;
-      bool end=false;
-
-      do {
-        int active=next;
-        if ( anchor==active ) end=true;
-        int d=_data[active].degree;
-        next=_data[active].right_neighbor;
-
-        while (A[d]!=-1) {
-          if( _comp(_data[active].prio, _data[A[d]].prio) ) {
-            fuse(active,A[d]);
-          } else {
-            fuse(A[d],active);
-            active=A[d];
-          }
-          A[d]=-1;
-          ++d;
-        }
-        A[d]=active;
-      } while ( !end );
-
-
-      while ( _data[_minimum].parent >=0 )
-        _minimum=_data[_minimum].parent;
-      int s=_minimum;
-      int m=_minimum;
-      do {
-        if ( _comp(_data[s].prio, _data[_minimum].prio) ) _minimum=s;
-        s=_data[s].right_neighbor;
-      } while ( s != m );
-    }
-
-    void makeRoot(int c) {
-      int s=c;
-      do {
-        _data[s].parent=-1;
-        s=_data[s].right_neighbor;
-      } while ( s != c );
-    }
-
-    void cut(int a, int b) {
-      /*
-       *Replacing a from the children of b.
-       */
-      --_data[b].degree;
-
-      if ( _data[b].degree !=0 ) {
-        int child=_data[b].child;
-        if ( child==a )
-          _data[b].child=_data[child].right_neighbor;
-        unlace(a);
-      }
-
-
-      /*Lacing a to the roots.*/
-      int right=_data[_minimum].right_neighbor;
-      _data[_minimum].right_neighbor=a;
-      _data[a].left_neighbor=_minimum;
-      _data[a].right_neighbor=right;
-      _data[right].left_neighbor=a;
-
-      _data[a].parent=-1;
-      _data[a].marked=false;
-    }
-
-    void cascade(int a) {
-      if ( _data[a].parent!=-1 ) {
-        int p=_data[a].parent;
-
-        if ( _data[a].marked==false ) _data[a].marked=true;
-        else {
-          cut(a,p);
-          cascade(p);
-        }
-      }
-    }
-
-    void fuse(int a, int b) {
-      unlace(b);
-
-      /*Lacing b under a.*/
-      _data[b].parent=a;
-
-      if (_data[a].degree==0) {
-        _data[b].left_neighbor=b;
-        _data[b].right_neighbor=b;
-        _data[a].child=b;
-      } else {
-        int child=_data[a].child;
-        int last_child=_data[child].left_neighbor;
-        _data[child].left_neighbor=b;
-        _data[b].right_neighbor=child;
-        _data[last_child].right_neighbor=b;
-        _data[b].left_neighbor=last_child;
-      }
-
-      ++_data[a].degree;
-
-      _data[b].marked=false;
-    }
-
-    /*
-     *It is invoked only if a has siblings.
-     */
-    void unlace(int a) {
-      int leftn=_data[a].left_neighbor;
-      int rightn=_data[a].right_neighbor;
-      _data[leftn].right_neighbor=rightn;
-      _data[rightn].left_neighbor=leftn;
-    }
-
-
-    class Store {
-      friend class FibHeap;
-
-      Item name;
-      int parent;
-      int left_neighbor;
-      int right_neighbor;
-      int child;
-      int degree;
-      bool marked;
-      bool in;
-      Prio prio;
-
-      Store() : parent(-1), child(-1), degree(), marked(false), in(true) {}
-    };
-  };
-
-} //namespace lemon
-
-#endif //LEMON_FIB_HEAP_H
-
Index: lemon/fourary_heap.h
===================================================================
--- lemon/fourary_heap.h	(revision 753)
+++ 	(revision )
@@ -1,342 +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_FOURARY_HEAP_H
-#define LEMON_FOURARY_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Fourary heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Fourary heap data structure.
-  ///
-  /// This class implements the \e fourary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The fourary heap is a specialization of the \ref KaryHeap "K-ary heap"
-  /// for <tt>K=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 KaryHeap
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class FouraryHeap {
-  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 FouraryHeap(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.
-    FouraryHeap(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 FouraryHeap
-
-} // namespace lemon
-
-#endif // LEMON_FOURARY_HEAP_H
Index: lemon/full_graph.h
===================================================================
--- lemon/full_graph.h	(revision 834)
+++ lemon/full_graph.h	(revision 664)
@@ -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);
     }
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 793)
+++ lemon/glpk.cc	(revision 623)
@@ -57,40 +57,4 @@
     int i = glp_add_rows(lp, 1);
     glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0);
-    return i;
-  }
-
-  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;
   }
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 793)
+++ lemon/glpk.h	(revision 623)
@@ -27,8 +27,7 @@
 
 // forward declaration
-#if !defined _GLP_PROB && !defined GLP_PROB
+#ifndef _GLP_PROB
 #define _GLP_PROB
-#define GLP_PROB
-typedef struct { double _opaque_prob; } glp_prob;
+typedef struct { double _prob; } glp_prob;
 /* LP/MIP problem object */
 #endif
@@ -55,5 +54,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/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 833)
+++ lemon/gomory_hu.h	(revision 643)
@@ -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;
@@ -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);
@@ -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
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 833)
+++ lemon/graph_to_eps.h	(revision 664)
@@ -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.
@@ -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/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/hartmann_orlin.h
===================================================================
--- lemon/hartmann_orlin.h	(revision 819)
+++ 	(revision )
@@ -1,640 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * 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_H
-#define LEMON_HARTMANN_ORLIN_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 HartmannOrlin algorithm.
-  ///
-  /// Default traits class of HartmannOrlin algorithm.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
-  /// It must conform to the \ref concepts::Rea_data "Rea_data" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN>
-#else
-  template <typename GR, typename LEN,
-    bool integer = std::numeric_limits<typename LEN::Value>::is_integer>
-#endif
-  struct HartmannOrlinDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the length map
-    typedef LEN LengthMap;
-    /// The type of the arc lengths
-    typedef typename LengthMap::Value Value;
-
-    /// \brief The large value type used for internal computations
-    ///
-    /// The large value type used for internal computations.
-    /// It is \c long \c long if the \c Value type is integer,
-    /// otherwise it is \c double.
-    /// \c Value must be convertible to \c LargeValue.
-    typedef double LargeValue;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeValue> 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 value types
-  template <typename GR, typename LEN>
-  struct HartmannOrlinDefaultTraits<GR, LEN, true>
-  {
-    typedef GR Digraph;
-    typedef LEN LengthMap;
-    typedef typename LengthMap::Value Value;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeValue;
-#else
-    typedef long LargeValue;
-#endif
-    typedef lemon::Tolerance<LargeValue> 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 length (cost) in a digraph
-  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
-  /// It is an improved version of \ref Karp "Karp"'s original algorithm,
-  /// it applies an efficient early termination scheme.
-  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam LEN The type of the length map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
-#else
-  template < typename GR,
-             typename LEN = typename GR::template ArcMap<int>,
-             typename TR = HartmannOrlinDefaultTraits<GR, LEN> >
-#endif
-  class HartmannOrlin
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the length map
-    typedef typename TR::LengthMap LengthMap;
-    /// The type of the arc lengths
-    typedef typename TR::Value Value;
-
-    /// \brief The large value type
-    ///
-    /// The large value type used for internal computations.
-    /// Using the \ref HartmannOrlinDefaultTraits "default traits class",
-    /// it is \c long \c long if the \c Value type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeValue LargeValue;
-
-    /// 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 HartmannOrlinDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref HartmannOrlinDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeValue dist;
-      Arc pred;
-      PathData(LargeValue 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 length of the arcs
-    const LengthMap &_length;
-
-    // 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;
-    LargeValue _curr_length, _best_length;
-    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 LargeValue INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeValueTraits : public Traits {
-      typedef T LargeValue;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeValue type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeValue
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeValue
-      : public HartmannOrlin<GR, LEN, SetLargeValueTraits<T> > {
-      typedef HartmannOrlin<GR, LEN, SetLargeValueTraits<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 HartmannOrlin<GR, LEN, SetPathTraits<T> > {
-      typedef HartmannOrlin<GR, LEN, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param length The lengths (costs) of the arcs.
-    HartmannOrlin( const Digraph &digraph,
-                   const LengthMap &length ) :
-      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),
-      _best_found(false), _best_length(0), _best_size(1),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeValue>::has_infinity ?
-          std::numeric_limits<LargeValue>::infinity() :
-          std::numeric_limits<LargeValue>::max())
-    {}
-
-    /// Destructor.
-    ~HartmannOrlin() {
-      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 findMinMean(), it will allocate a local \ref Path "path"
-    /// structure. 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>
-    HartmannOrlin& 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>
-    HartmannOrlin& 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 length, you may call
-    /// \ref findMinMean().
-
-    /// @{
-
-    /// \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 lengths 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.findMinMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findMinMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean length of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findMinMean() {
-      // 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_length * _best_size < _best_length * _curr_size) ) {
-          _best_found = true;
-          _best_length = _curr_length;
-          _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 length
-    /// in the digraph using the data computed by findMinMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findMinMean() 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_length = _length[e];
-      _best_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _best_length += _length[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 length of the found cycle.
-    ///
-    /// This function returns the total length of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findMinMean() must be called before
-    /// using this function.
-    LargeValue cycleLength() const {
-      return _best_length;
-    }
-
-    /// \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 findMinMean() must be called before
-    /// using this function.
-    int cycleArcNum() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean length of the found cycle.
-    ///
-    /// This function returns the mean length of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleLength()) / alg.cycleArcNum();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findMinMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_length) / _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_length = 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 length 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;
-      LargeValue 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 + _length[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;
-      LargeValue 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 + _length[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<LargeValue> pi(_gr);
-      int n = _nodes->size();
-      LargeValue length;
-      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
-            length = _data[u][level[u].second].dist - _data[u][j].dist;
-            size = level[u].second - j;
-            if (!_curr_found || length * _curr_size < _curr_length * size) {
-              _curr_length = length;
-              _curr_size = size;
-              _curr_node = u;
-              _curr_level = level[u].second;
-              _curr_found = true;
-            }
-          }
-          level[u] = Pair(i, j);
-          u = _gr.source(_data[u][j].pred);
-        }
-      }
-
-      // If at least one cycle is found, check the optimality condition
-      LargeValue 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_length;
-              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(_length[a] * _curr_size - _curr_length,
-                              pi[_gr.target(a)] - pi[_gr.source(a)]) ) {
-            done = false;
-            break;
-          }
-        }
-        return done;
-      }
-      return (k == n);
-    }
-
-  }; //class HartmannOrlin
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HARTMANN_ORLIN_H
Index: lemon/howard.h
===================================================================
--- lemon/howard.h	(revision 818)
+++ 	(revision )
@@ -1,597 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * 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_H
-#define LEMON_HOWARD_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 Howard class.
-  ///
-  /// Default traits class of Howard class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN>
-#else
-  template <typename GR, typename LEN,
-    bool integer = std::numeric_limits<typename LEN::Value>::is_integer>
-#endif
-  struct HowardDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the length map
-    typedef LEN LengthMap;
-    /// The type of the arc lengths
-    typedef typename LengthMap::Value Value;
-
-    /// \brief The large value type used for internal computations
-    ///
-    /// The large value type used for internal computations.
-    /// It is \c long \c long if the \c Value type is integer,
-    /// otherwise it is \c double.
-    /// \c Value must be convertible to \c LargeValue.
-    typedef double LargeValue;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeValue> 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 value types
-  template <typename GR, typename LEN>
-  struct HowardDefaultTraits<GR, LEN, true>
-  {
-    typedef GR Digraph;
-    typedef LEN LengthMap;
-    typedef typename LengthMap::Value Value;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeValue;
-#else
-    typedef long LargeValue;
-#endif
-    typedef lemon::Tolerance<LargeValue> 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 length (cost) in a digraph
-  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
-  /// 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 LEN The type of the length map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
-#else
-  template < typename GR,
-             typename LEN = typename GR::template ArcMap<int>,
-             typename TR = HowardDefaultTraits<GR, LEN> >
-#endif
-  class Howard
-  {
-  public:
-  
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the length map
-    typedef typename TR::LengthMap LengthMap;
-    /// The type of the arc lengths
-    typedef typename TR::Value Value;
-
-    /// \brief The large value type
-    ///
-    /// The large value type used for internal computations.
-    /// Using the \ref HowardDefaultTraits "default traits class",
-    /// it is \c long \c long if the \c Value type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeValue LargeValue;
-
-    /// 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 HowardDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref HowardDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The length of the arcs
-    const LengthMap &_length;
-
-    // Data for the found cycles
-    bool _curr_found, _best_found;
-    LargeValue _curr_length, _best_length;
-    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<LargeValue> _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 LargeValue INF;
-
-  public:
-  
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeValueTraits : public Traits {
-      typedef T LargeValue;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeValue type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeValue
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeValue
-      : public Howard<GR, LEN, SetLargeValueTraits<T> > {
-      typedef Howard<GR, LEN, SetLargeValueTraits<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 Howard<GR, LEN, SetPathTraits<T> > {
-      typedef Howard<GR, LEN, SetPathTraits<T> > Create;
-    };
-    
-    /// @}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param length The lengths (costs) of the arcs.
-    Howard( const Digraph &digraph,
-            const LengthMap &length ) :
-      _gr(digraph), _length(length), _best_found(false),
-      _best_length(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<LargeValue>::has_infinity ?
-          std::numeric_limits<LargeValue>::infinity() :
-          std::numeric_limits<LargeValue>::max())
-    {}
-
-    /// Destructor.
-    ~Howard() {
-      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 findMinMean(), it will allocate a local \ref Path "path"
-    /// structure. 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>
-    Howard& 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>
-    Howard& 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 length, you may call
-    /// \ref findMinMean().
-
-    /// @{
-
-    /// \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 lengths 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.findMinMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findMinMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean length of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findMinMean() {
-      // Initialize and find strongly connected components
-      init();
-      findComponents();
-      
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        // Find the minimum mean cycle in the current component
-        if (!buildPolicyGraph(comp)) continue;
-        while (true) {
-          findPolicyCycle();
-          if (!computeNodeDistances()) break;
-        }
-        // Update the best cycle (global minimum mean cycle)
-        if ( _curr_found && (!_best_found ||
-             _curr_length * _best_size < _best_length * _curr_size) ) {
-          _best_found = true;
-          _best_length = _curr_length;
-          _best_size = _curr_size;
-          _best_node = _curr_node;
-        }
-      }
-      return _best_found;
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean length
-    /// in the digraph using the data computed by findMinMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findMinMean() 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 length of the found cycle.
-    ///
-    /// This function returns the total length of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findMinMean() must be called before
-    /// using this function.
-    LargeValue cycleLength() const {
-      return _best_length;
-    }
-
-    /// \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 findMinMean() must be called before
-    /// using this function.
-    int cycleArcNum() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean length of the found cycle.
-    ///
-    /// This function returns the mean length of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleLength()) / alg.cycleArcNum();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findMinMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_length) / _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_length = 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 (_length[e] < _dist[u]) {
-            _dist[u] = _length[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;
-      }
-      LargeValue clength;
-      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
-          clength = _length[_policy[u]];
-          csize = 1;
-          for (v = u; (v = _gr.target(_policy[v])) != u; ) {
-            clength += _length[_policy[v]];
-            ++csize;
-          }
-          if ( !_curr_found ||
-               (clength * _curr_size < _curr_length * csize) ) {
-            _curr_found = true;
-            _curr_length = clength;
-            _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] + _length[e] * _curr_size - _curr_length;
-            _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] + _length[e] * _curr_size - _curr_length;
-            _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);
-          LargeValue delta = _dist[v] + _length[e] * _curr_size - _curr_length;
-          if (_tolerance.less(delta, _dist[u])) {
-            _dist[u] = delta;
-            _policy[u] = e;
-            improved = true;
-          }
-        }
-      }
-      return improved;
-    }
-
-  }; //class Howard
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HOWARD_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/karp.h
===================================================================
--- lemon/karp.h	(revision 819)
+++ 	(revision )
@@ -1,582 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * 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_H
-#define LEMON_KARP_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 Karp algorithm.
-  ///
-  /// Default traits class of Karp algorithm.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN>
-#else
-  template <typename GR, typename LEN,
-    bool integer = std::numeric_limits<typename LEN::Value>::is_integer>
-#endif
-  struct KarpDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the length map
-    typedef LEN LengthMap;
-    /// The type of the arc lengths
-    typedef typename LengthMap::Value Value;
-
-    /// \brief The large value type used for internal computations
-    ///
-    /// The large value type used for internal computations.
-    /// It is \c long \c long if the \c Value type is integer,
-    /// otherwise it is \c double.
-    /// \c Value must be convertible to \c LargeValue.
-    typedef double LargeValue;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeValue> 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 value types
-  template <typename GR, typename LEN>
-  struct KarpDefaultTraits<GR, LEN, true>
-  {
-    typedef GR Digraph;
-    typedef LEN LengthMap;
-    typedef typename LengthMap::Value Value;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeValue;
-#else
-    typedef long LargeValue;
-#endif
-    typedef lemon::Tolerance<LargeValue> 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 length (cost) in a digraph
-  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
-  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam LEN The type of the length map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
-#else
-  template < typename GR,
-             typename LEN = typename GR::template ArcMap<int>,
-             typename TR = KarpDefaultTraits<GR, LEN> >
-#endif
-  class Karp
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the length map
-    typedef typename TR::LengthMap LengthMap;
-    /// The type of the arc lengths
-    typedef typename TR::Value Value;
-
-    /// \brief The large value type
-    ///
-    /// The large value type used for internal computations.
-    /// Using the \ref KarpDefaultTraits "default traits class",
-    /// it is \c long \c long if the \c Value type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeValue LargeValue;
-
-    /// 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 KarpDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref KarpDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeValue dist;
-      Arc pred;
-      PathData(LargeValue 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 length of the arcs
-    const LengthMap &_length;
-
-    // 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
-    LargeValue _cycle_length;
-    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 LargeValue INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeValueTraits : public Traits {
-      typedef T LargeValue;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeValue type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeValue
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeValue
-      : public Karp<GR, LEN, SetLargeValueTraits<T> > {
-      typedef Karp<GR, LEN, SetLargeValueTraits<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 Karp<GR, LEN, SetPathTraits<T> > {
-      typedef Karp<GR, LEN, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param length The lengths (costs) of the arcs.
-    Karp( const Digraph &digraph,
-          const LengthMap &length ) :
-      _gr(digraph), _length(length), _comp(digraph), _out_arcs(digraph),
-      _cycle_length(0), _cycle_size(1), _cycle_node(INVALID),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeValue>::has_infinity ?
-          std::numeric_limits<LargeValue>::infinity() :
-          std::numeric_limits<LargeValue>::max())
-    {}
-
-    /// Destructor.
-    ~Karp() {
-      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 findMinMean(), it will allocate a local \ref Path "path"
-    /// structure. 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>
-    Karp& 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>
-    Karp& 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 length, you may call
-    /// \ref findMinMean().
-
-    /// @{
-
-    /// \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 lengths 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.findMinMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findMinMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean length of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findMinMean() {
-      // 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 length
-    /// in the digraph using the data computed by findMinMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findMinMean() 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_length = _length[e];
-      _cycle_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _cycle_length += _length[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 length of the found cycle.
-    ///
-    /// This function returns the total length of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findMinMean() must be called before
-    /// using this function.
-    LargeValue cycleLength() const {
-      return _cycle_length;
-    }
-
-    /// \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 findMinMean() must be called before
-    /// using this function.
-    int cycleArcNum() const {
-      return _cycle_size;
-    }
-
-    /// \brief Return the mean length of the found cycle.
-    ///
-    /// This function returns the mean length of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleLength()) / alg.cycleArcNum();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findMinMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_cycle_length) / _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_length = 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 length 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;
-      LargeValue 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 + _length[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;
-      LargeValue 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 + _length[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;
-        LargeValue length, max_length = 0;
-        int size, max_size = 1;
-        bool found_curr = false;
-        for (int k = 0; k < n; ++k) {
-          if (_data[u][k].dist == INF) continue;
-          length = _data[u][n].dist - _data[u][k].dist;
-          size = n - k;
-          if (!found_curr || length * max_size > max_length * size) {
-            found_curr = true;
-            max_length = length;
-            max_size = size;
-          }
-        }
-        if ( found_curr && (_cycle_node == INVALID ||
-             max_length * _cycle_size < _cycle_length * max_size) ) {
-          _cycle_length = max_length;
-          _cycle_size = max_size;
-          _cycle_node = u;
-        }
-      }
-    }
-
-  }; //class Karp
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_KARP_H
Index: lemon/kary_heap.h
===================================================================
--- lemon/kary_heap.h	(revision 753)
+++ 	(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_KARY_HEAP_H
-#define LEMON_KARY_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Fourary heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief K-ary heap data structure.
-  ///
-  /// This class implements the \e K-ary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The \ref KaryHeap "K-ary heap" is a generalization of the
-  /// \ref BinHeap "binary heap" structure, its nodes have at most
-  /// \c K children, instead of two.
-  /// \ref BinHeap and \ref FouraryHeap are specialized implementations
-  /// of this structure for <tt>K=2</tt> and <tt>K=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 K The degree of the heap, each node have at most \e K
-  /// 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 K, typename CMP>
-#else
-  template <typename PR, typename IM, int K = 16,
-            typename CMP = std::less<PR> >
-#endif
-  class KaryHeap {
-  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 KaryHeap(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.
-    KaryHeap(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)/K; }
-    int firstChild(int i) { return K*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+K<=length ) {
-          int min=child;
-          for (int i=1; i<K; ++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 KaryHeap
-
-} // namespace lemon
-
-#endif // LEMON_KARY_HEAP_H
Index: lemon/lemon.pc.in
===================================================================
--- lemon/lemon.pc.in	(revision 705)
+++ lemon/lemon.pc.in	(revision 692)
@@ -5,5 +5,5 @@
 
 Name: @PACKAGE_NAME@
-Description: Library for Efficient Modeling and Optimization in Networks
+Description: Library of Efficient Models and Optimization in Networks
 Version: @PACKAGE_VERSION@
 Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 833)
+++ lemon/lgf_reader.h	(revision 646)
@@ -428,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
@@ -2222,5 +2222,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/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 835)
+++ lemon/list_graph.h	(revision 664)
@@ -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 incomming 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();
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 833)
+++ lemon/lp_base.h	(revision 631)
@@ -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
@@ -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
@@ -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;
@@ -1216,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;
     }
@@ -1228,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():-INF, 
-                                ExprIterator(c.expr().comps.begin(), cols),
-                                ExprIterator(c.expr().comps.end(), cols),
-                                c.upperBounded()?c.upperBound():INF));
+      Row r=addRow();
+      row(r,c);
       return r;
     }
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 793)
+++ lemon/lp_skeleton.cc	(revision 623)
@@ -29,9 +29,4 @@
 
   int SkeletonSolverBase::_addRow()
-  {
-    return ++row_num;
-  }
-
-  int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
   {
     return ++row_num;
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 793)
+++ lemon/lp_skeleton.h	(revision 623)
@@ -45,6 +45,4 @@
     /// \e
     virtual int _addRow();
-    /// \e
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
     /// \e
     virtual void _eraseCol(int i);
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 839)
+++ lemon/maps.h	(revision 664)
@@ -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,8 +232,8 @@
   /// 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
-  /// "ReferenceMap" concept. 
+  /// 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.
   ///
   /// The simplest way of using this map is through the rangeMap()
@@ -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,32 +1899,14 @@
   };
 
-  /// \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.
 
   /// This class provides simple invertable graph maps.
-  /// 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.
-  ///
-  /// This type is not reference map, so it cannot be modified with
-  /// the subscript operator.
+  /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
+  /// and if a key is set to a new value then store it
+  /// in the inverse map.
+  ///
+  /// The values of the map can be accessed
+  /// with stl compatible forward iterator.
   ///
   /// \tparam GR The graph type.
@@ -1943,5 +1924,5 @@
       template Map<V>::Type Map;
 
-    typedef std::multimap<V, K> Container;
+    typedef std::map<V, K> Container;
     Container _inv_map;
 
@@ -1965,64 +1946,52 @@
     /// \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:
       typename Container::const_iterator it;
     };
-    
-    /// 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());
     }
 
@@ -2032,13 +2001,9 @@
     void set(const Key& key, const Value& val) {
       Value oldval = Map::operator[](key);
-      typename Container::iterator it;
-      for (it = _inv_map.equal_range(oldval).first;
-           it != _inv_map.equal_range(oldval).second; ++it) {
-        if (it->second == key) {
-          _inv_map.erase(it);
-          break;
-        }
+      typename Container::iterator it = _inv_map.find(oldval);
+      if (it != _inv_map.end() && it->second == key) {
+        _inv_map.erase(it);
       }
-      _inv_map.insert(std::make_pair(val, key));
+      _inv_map.insert(make_pair(val, key));
       Map::set(key, val);
     }
@@ -2052,21 +2017,10 @@
     }
 
-    /// \brief Gives back an item by its value.
-    ///
-    /// This function gives back an item that is assigned to
-    /// the given value or \c INVALID if no such item exists.
-    /// If there are more items with the same associated value,
-    /// only one of them is returned.
-    Key operator()(const Value& val) const {
-      typename Container::const_iterator it = _inv_map.find(val);
+    /// \brief Gives back the item by its value.
+    ///
+    /// Gives back the item by its value.
+    Key operator()(const Value& key) const {
+      typename Container::const_iterator it = _inv_map.find(key);
       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);
     }
 
@@ -2079,11 +2033,7 @@
     virtual void erase(const Key& key) {
       Value val = Map::operator[](key);
-      typename Container::iterator it;
-      for (it = _inv_map.equal_range(val).first;
-           it != _inv_map.equal_range(val).second; ++it) {
-        if (it->second == key) {
-          _inv_map.erase(it);
-          break;
-        }
+      typename Container::iterator it = _inv_map.find(val);
+      if (it != _inv_map.end() && it->second == key) {
+        _inv_map.erase(it);
       }
       Map::erase(key);
@@ -2097,11 +2047,7 @@
       for (int i = 0; i < int(keys.size()); ++i) {
         Value val = Map::operator[](keys[i]);
-        typename Container::iterator it;
-        for (it = _inv_map.equal_range(val).first;
-             it != _inv_map.equal_range(val).second; ++it) {
-          if (it->second == keys[i]) {
-            _inv_map.erase(it);
-            break;
-          }
+        typename Container::iterator it = _inv_map.find(val);
+        if (it != _inv_map.end() && it->second == keys[i]) {
+          _inv_map.erase(it);
         }
       }
@@ -2120,10 +2066,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:
@@ -2141,7 +2085,6 @@
       /// \brief Subscript operator.
       ///
-      /// Subscript operator. It gives back an item
-      /// that is assigned to the given value or \c INVALID
-      /// if no such item exists.
+      /// Subscript operator. It gives back the item
+      /// that was last assigned to the given value.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2152,7 +2095,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 +2104,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 +2119,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 +2247,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 +2270,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 +2288,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 +2306,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);
-      unlace(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 +2322,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 +2363,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 +2405,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 +2445,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 +2481,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 +2497,5 @@
 
   public:
-
+    
     /// The graph type of InDegMap
     typedef GR Graph;
@@ -3594,8 +2611,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 +2782,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 698)
+++ lemon/matching.h	(revision 641)
@@ -500,5 +500,5 @@
     /// This function runs the original Edmonds' algorithm.
     ///
-    /// \pre \ref init(), \ref greedyInit() or \ref matchingInit() must be
+    /// \pre \ref Init(), \ref greedyInit() or \ref matchingInit() must be
     /// called before using this function.
     void startSparse() {
@@ -519,5 +519,5 @@
     /// shrinks, therefore resulting in a faster algorithm for dense graphs.
     ///
-    /// \pre \ref init(), \ref greedyInit() or \ref matchingInit() must be
+    /// \pre \ref Init(), \ref greedyInit() or \ref matchingInit() must be
     /// called before using this function.
     void startDense() {
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 760)
+++ lemon/min_cost_arborescence.h	(revision 672)
@@ -489,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/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 835)
+++ lemon/network_simplex.h	(revision 690)
@@ -20,5 +20,5 @@
 #define LEMON_NETWORK_SIMPLEX_H
 
-/// \ingroup min_cost_flow_algs
+/// \ingroup min_cost_flow
 ///
 /// \file
@@ -34,5 +34,5 @@
 namespace lemon {
 
-  /// \addtogroup min_cost_flow_algs
+  /// \addtogroup min_cost_flow
   /// @{
 
@@ -41,7 +41,5 @@
   ///
   /// \ref NetworkSimplex implements the primal Network Simplex algorithm
-  /// for finding a \ref min_cost_flow "minimum cost flow"
-  /// \ref amo93networkflows, \ref dantzig63linearprog,
-  /// \ref kellyoneill91netsimplex.
+  /// 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.
@@ -51,5 +49,5 @@
   /// 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.
+  /// constraints. For more information see \ref SupplyType.
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -60,7 +58,7 @@
   /// \tparam GR The digraph type the algorithm runs on.
   /// \tparam V The value type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
+  /// 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.
+  /// algorithm. By default it is the same as \c V.
   ///
   /// \warning Both value types must be signed and all input data must
@@ -69,5 +67,5 @@
   /// \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
@@ -105,14 +103,48 @@
     /// constraints of the \ref min_cost_flow "minimum cost flow problem".
     ///
-    /// The default supply type is \c GEQ, the \c LEQ type can be
-    /// selected using \ref supplyType().
-    /// The equality form is a special case of both supply types.
+    /// The default supply type is \c GEQ, since this form is supported
+    /// by other minimum cost flow algorithms and the \ref Circulation
+    /// algorithm, as well.
+    /// The \c LEQ problem type can be selected using the \ref supplyType()
+    /// function.
+    ///
+    /// Note that the equality form is a special case of both supply types.
     enum SupplyType {
+
       /// This option means that there are <em>"greater or equal"</em>
-      /// supply/demand constraints in the definition of the problem.
+      /// supply/demand constraints in the definition, i.e. the exact
+      /// formulation of the problem is the following.
+      /**
+          \f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]
+          \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \geq
+              sup(u) \quad \forall u\in V \f]
+          \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
+      */
+      /// It means that the total demand must be greater or equal to the 
+      /// total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
+      /// negative) and all the supplies have to be carried out from 
+      /// the supply nodes, but there could be demands that are not 
+      /// satisfied.
       GEQ,
+      /// It is just an alias for the \c GEQ option.
+      CARRY_SUPPLIES = GEQ,
+
       /// This option means that there are <em>"less or equal"</em>
-      /// supply/demand constraints in the definition of the problem.
-      LEQ
+      /// supply/demand constraints in the definition, i.e. the exact
+      /// formulation of the problem is the following.
+      /**
+          \f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]
+          \f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \leq
+              sup(u) \quad \forall u\in V \f]
+          \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
+      */
+      /// It means that the total demand must be less or equal to the 
+      /// total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
+      /// positive) and all the demands have to be satisfied, but there
+      /// could be supplies that are not carried out from the supply
+      /// nodes.
+      LEQ,
+      /// It is just an alias for the \c LEQ option.
+      SATISFY_DEMANDS = LEQ
     };
     
@@ -125,21 +157,21 @@
     /// implementations that significantly affect the running time
     /// of the algorithm.
-    /// By default, \ref BLOCK_SEARCH "Block Search" is used, which
+    /// 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()
+    /// 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
@@ -147,5 +179,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
@@ -153,5 +185,5 @@
       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 the several best eligible arcs from the former
@@ -164,4 +196,6 @@
     TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 
+    typedef std::vector<Arc> ArcVector;
+    typedef std::vector<Node> NodeVector;
     typedef std::vector<int> IntVector;
     typedef std::vector<bool> BoolVector;
@@ -182,6 +216,4 @@
     int _node_num;
     int _arc_num;
-    int _all_arc_num;
-    int _search_arc_num;
 
     // Parameters of the problem
@@ -246,5 +278,5 @@
       const CostVector &_pi;
       int &_in_arc;
-      int _search_arc_num;
+      int _arc_num;
 
       // Pivot rule data
@@ -257,6 +289,5 @@
         _source(ns._source), _target(ns._target),
         _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0)
+        _in_arc(ns.in_arc), _arc_num(ns._arc_num), _next_arc(0)
       {}
 
@@ -264,5 +295,5 @@
       bool findEnteringArc() {
         Cost c;
-        for (int e = _next_arc; e < _search_arc_num; ++e) {
+        for (int e = _next_arc; e < _arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -298,5 +329,5 @@
       const CostVector &_pi;
       int &_in_arc;
-      int _search_arc_num;
+      int _arc_num;
 
     public:
@@ -306,5 +337,5 @@
         _source(ns._source), _target(ns._target),
         _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num)
+        _in_arc(ns.in_arc), _arc_num(ns._arc_num)
       {}
 
@@ -312,5 +343,5 @@
       bool findEnteringArc() {
         Cost c, min = 0;
-        for (int e = 0; e < _search_arc_num; ++e) {
+        for (int e = 0; e < _arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
@@ -337,5 +368,5 @@
       const CostVector &_pi;
       int &_in_arc;
-      int _search_arc_num;
+      int _arc_num;
 
       // Pivot rule data
@@ -349,13 +380,12 @@
         _source(ns._source), _target(ns._target),
         _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0)
+        _in_arc(ns.in_arc), _arc_num(ns._arc_num), _next_arc(0)
       {
         // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 0.5;
+        const double BLOCK_SIZE_FACTOR = 2.0;
         const int MIN_BLOCK_SIZE = 10;
 
         _block_size = std::max( int(BLOCK_SIZE_FACTOR *
-                                    std::sqrt(double(_search_arc_num))),
+                                    std::sqrt(double(_arc_num))),
                                 MIN_BLOCK_SIZE );
       }
@@ -365,30 +395,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 < _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;
@@ -410,5 +441,5 @@
       const CostVector &_pi;
       int &_in_arc;
-      int _search_arc_num;
+      int _arc_num;
 
       // Pivot rule data
@@ -424,9 +455,8 @@
         _source(ns._source), _target(ns._target),
         _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0)
+        _in_arc(ns.in_arc), _arc_num(ns._arc_num), _next_arc(0)
       {
         // 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;
@@ -434,5 +464,5 @@
 
         _list_length = std::max( int(LIST_LENGTH_FACTOR *
-                                     std::sqrt(double(_search_arc_num))),
+                                     std::sqrt(double(_arc_num))),
                                  MIN_LIST_LENGTH );
         _minor_limit = std::max( int(MINOR_LIMIT_FACTOR * _list_length),
@@ -445,5 +475,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
@@ -456,11 +486,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;
+          }
         }
 
@@ -468,5 +501,5 @@
         min = 0;
         _curr_length = 0;
-        for (e = _next_arc; e < _search_arc_num; ++e) {
+        for (e = _next_arc; e < _arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -474,24 +507,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;
@@ -513,5 +547,5 @@
       const CostVector &_pi;
       int &_in_arc;
-      int _search_arc_num;
+      int _arc_num;
 
       // Pivot rule data
@@ -541,9 +575,9 @@
         _source(ns._source), _target(ns._target),
         _cost(ns._cost), _state(ns._state), _pi(ns._pi),
-        _in_arc(ns.in_arc), _search_arc_num(ns._search_arc_num),
-        _next_arc(0), _cand_cost(ns._search_arc_num), _sort_func(_cand_cost)
+        _in_arc(ns.in_arc), _arc_num(ns._arc_num),
+        _next_arc(0), _cand_cost(ns._arc_num), _sort_func(_cand_cost)
       {
         // 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.1;
@@ -551,5 +585,5 @@
 
         _block_size = std::max( int(BLOCK_SIZE_FACTOR *
-                                    std::sqrt(double(_search_arc_num))),
+                                    std::sqrt(double(_arc_num))),
                                 MIN_BLOCK_SIZE );
         _head_length = std::max( int(HEAD_LENGTH_FACTOR * _block_size),
@@ -574,33 +608,37 @@
         // Extend the list
         int cnt = _block_size;
+        int last_arc = 0;
         int limit = _head_length;
 
-        for (e = _next_arc; e < _search_arc_num; ++e) {
+        for (int e = _next_arc; e < _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) {
-          _cand_cost[e] = _state[e] *
-            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (_cand_cost[e] < 0) {
-            _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:
+        _next_arc = last_arc + 1;
 
         // Make heap of the candidate list (approximating a partial sort)
@@ -610,5 +648,4 @@
         // Pop the first element of the heap
         _in_arc = _candidates[0];
-        _next_arc = e;
         pop_heap( _candidates.begin(), _candidates.begin() + _curr_length,
                   _sort_func );
@@ -626,9 +663,5 @@
     ///
     /// \param graph The digraph the algorithm runs on.
-    /// \param arc_mixing Indicate if the arcs have to be stored in a
-    /// mixed order in the internal data structure. 
-    /// In special cases, it could lead to better overall performance,
-    /// but it is usually slower. Therefore it is disabled by default.
-    NetworkSimplex(const GR& graph, bool arc_mixing = false) :
+    NetworkSimplex(const GR& graph) :
       _graph(graph), _node_id(graph), _arc_id(graph),
       INF(std::numeric_limits<Value>::has_infinity ?
@@ -646,15 +679,15 @@
       _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);
+      int all_arc_num = _arc_num + _node_num;
+
+      _source.resize(all_arc_num);
+      _target.resize(all_arc_num);
+
+      _lower.resize(all_arc_num);
+      _upper.resize(all_arc_num);
+      _cap.resize(all_arc_num);
+      _cost.resize(all_arc_num);
       _supply.resize(all_node_num);
-      _flow.resize(max_arc_num);
+      _flow.resize(all_arc_num);
       _pi.resize(all_node_num);
 
@@ -666,33 +699,31 @@
       _succ_num.resize(all_node_num);
       _last_succ.resize(all_node_num);
-      _state.resize(max_arc_num);
-
-      // Copy the graph
+      _state.resize(all_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;
       }
-      if (arc_mixing) {
-        // Store the arcs in a mixed order
-        int k = std::max(int(std::sqrt(double(_arc_num))), 10);
-        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 += k) >= _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)];
-        }
+      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;
       }
       
-      // Reset parameters
-      reset();
+      // 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;
     }
 
@@ -767,4 +798,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.
@@ -787,4 +819,5 @@
     /// 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()
@@ -813,5 +846,5 @@
     /// type will be used.
     ///
-    /// For more information, see \ref SupplyType.
+    /// For more information see \ref SupplyType.
     ///
     /// \return <tt>(*this)</tt>
@@ -845,9 +878,9 @@
     /// \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
+    /// 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,
@@ -874,5 +907,5 @@
     /// used, all the parameters given before are kept for the next
     /// \ref run() call.
-    /// However, the underlying digraph must not be modified after this
+    /// However the underlying digraph must not be modified after this
     /// class have been constructed, since it copies and extends the graph.
     ///
@@ -1037,5 +1070,5 @@
       Cost ART_COST;
       if (std::numeric_limits<Cost>::is_exact) {
-        ART_COST = std::numeric_limits<Cost>::max() / 2 + 1;
+        ART_COST = std::numeric_limits<Cost>::max() / 4 + 1;
       } else {
         ART_COST = std::numeric_limits<Cost>::min();
@@ -1061,118 +1094,26 @@
       _last_succ[_root] = _root - 1;
       _supply[_root] = -_sum_supply;
-      _pi[_root] = 0;
+      _pi[_root] = _sum_supply < 0 ? -ART_COST : ART_COST;
 
       // Add artificial arcs and initialize the spanning tree data structure
-      if (_sum_supply == 0) {
-        // EQ supply constraints
-        _search_arc_num = _arc_num;
-        _all_arc_num = _arc_num + _node_num;
-        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
-          _parent[u] = _root;
-          _pred[u] = e;
-          _thread[u] = u + 1;
-          _rev_thread[u + 1] = u;
-          _succ_num[u] = 1;
-          _last_succ[u] = u;
-          _cap[e] = INF;
-          _state[e] = STATE_TREE;
-          if (_supply[u] >= 0) {
-            _forward[u] = true;
-            _pi[u] = 0;
-            _source[e] = u;
-            _target[e] = _root;
-            _flow[e] = _supply[u];
-            _cost[e] = 0;
-          } else {
-            _forward[u] = false;
-            _pi[u] = ART_COST;
-            _source[e] = _root;
-            _target[e] = u;
-            _flow[e] = -_supply[u];
-            _cost[e] = ART_COST;
-          }
-        }
-      }
-      else if (_sum_supply > 0) {
-        // LEQ supply constraints
-        _search_arc_num = _arc_num + _node_num;
-        int f = _arc_num + _node_num;
-        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
-          _parent[u] = _root;
-          _thread[u] = u + 1;
-          _rev_thread[u + 1] = u;
-          _succ_num[u] = 1;
-          _last_succ[u] = u;
-          if (_supply[u] >= 0) {
-            _forward[u] = true;
-            _pi[u] = 0;
-            _pred[u] = e;
-            _source[e] = u;
-            _target[e] = _root;
-            _cap[e] = INF;
-            _flow[e] = _supply[u];
-            _cost[e] = 0;
-            _state[e] = STATE_TREE;
-          } else {
-            _forward[u] = false;
-            _pi[u] = ART_COST;
-            _pred[u] = f;
-            _source[f] = _root;
-            _target[f] = u;
-            _cap[f] = INF;
-            _flow[f] = -_supply[u];
-            _cost[f] = ART_COST;
-            _state[f] = STATE_TREE;
-            _source[e] = u;
-            _target[e] = _root;
-            _cap[e] = INF;
-            _flow[e] = 0;
-            _cost[e] = 0;
-            _state[e] = STATE_LOWER;
-            ++f;
-          }
-        }
-        _all_arc_num = f;
-      }
-      else {
-        // GEQ supply constraints
-        _search_arc_num = _arc_num + _node_num;
-        int f = _arc_num + _node_num;
-        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
-          _parent[u] = _root;
-          _thread[u] = u + 1;
-          _rev_thread[u + 1] = u;
-          _succ_num[u] = 1;
-          _last_succ[u] = u;
-          if (_supply[u] <= 0) {
-            _forward[u] = false;
-            _pi[u] = 0;
-            _pred[u] = e;
-            _source[e] = _root;
-            _target[e] = u;
-            _cap[e] = INF;
-            _flow[e] = -_supply[u];
-            _cost[e] = 0;
-            _state[e] = STATE_TREE;
-          } else {
-            _forward[u] = true;
-            _pi[u] = -ART_COST;
-            _pred[u] = f;
-            _source[f] = u;
-            _target[f] = _root;
-            _cap[f] = INF;
-            _flow[f] = _supply[u];
-            _state[f] = STATE_TREE;
-            _cost[f] = ART_COST;
-            _source[e] = _root;
-            _target[e] = u;
-            _cap[e] = INF;
-            _flow[e] = 0;
-            _cost[e] = 0;
-            _state[e] = STATE_LOWER;
-            ++f;
-          }
-        }
-        _all_arc_num = f;
+      for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
+        _parent[u] = _root;
+        _pred[u] = e;
+        _thread[u] = u + 1;
+        _rev_thread[u + 1] = u;
+        _succ_num[u] = 1;
+        _last_succ[u] = u;
+        _cost[e] = ART_COST;
+        _cap[e] = INF;
+        _state[e] = STATE_TREE;
+        if (_supply[u] > 0 || (_supply[u] == 0 && _sum_supply <= 0)) {
+          _flow[e] = _supply[u];
+          _forward[u] = true;
+          _pi[u] = -ART_COST + _pi[_root];
+        } else {
+          _flow[e] = -_supply[u];
+          _forward[u] = false;
+          _pi[u] = ART_COST + _pi[_root];
+        }
       }
 
@@ -1434,6 +1375,18 @@
       
       // Check feasibility
-      for (int e = _search_arc_num; e != _all_arc_num; ++e) {
-        if (_flow[e] != 0) return INFEASIBLE;
+      if (_sum_supply < 0) {
+        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
+          if (_supply[u] >= 0 && _flow[e] != 0) return INFEASIBLE;
+        }
+      }
+      else if (_sum_supply > 0) {
+        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
+          if (_supply[u] <= 0 && _flow[e] != 0) return INFEASIBLE;
+        }
+      }
+      else {
+        for (int u = 0, e = _arc_num; u != _node_num; ++u, ++e) {
+          if (_flow[e] != 0) return INFEASIBLE;
+        }
       }
 
@@ -1449,28 +1402,4 @@
         }
       }
-      
-      // Shift potentials to meet the requirements of the GEQ/LEQ type
-      // optimality conditions
-      if (_sum_supply == 0) {
-        if (_stype == GEQ) {
-          Cost max_pot = std::numeric_limits<Cost>::min();
-          for (int i = 0; i != _node_num; ++i) {
-            if (_pi[i] > max_pot) max_pot = _pi[i];
-          }
-          if (max_pot > 0) {
-            for (int i = 0; i != _node_num; ++i)
-              _pi[i] -= max_pot;
-          }
-        } else {
-          Cost min_pot = std::numeric_limits<Cost>::max();
-          for (int i = 0; i != _node_num; ++i) {
-            if (_pi[i] < min_pot) min_pot = _pi[i];
-          }
-          if (min_pot < 0) {
-            for (int i = 0; i != _node_num; ++i)
-              _pi[i] -= min_pot;
-          }
-        }
-      }
 
       return OPTIMAL;
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 831)
+++ lemon/path.h	(revision 606)
@@ -71,5 +71,5 @@
     template <typename CPath>
     Path(const CPath& cpath) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
     }
 
@@ -79,5 +79,5 @@
     template <typename CPath>
     Path& operator=(const CPath& cpath) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
       return *this;
     }
@@ -259,5 +259,5 @@
     template <typename CPath>
     SimplePath(const CPath& cpath) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
     }
 
@@ -268,5 +268,5 @@
     template <typename CPath>
     SimplePath& operator=(const CPath& cpath) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
       return *this;
     }
@@ -438,5 +438,5 @@
     template <typename CPath>
     ListPath(const CPath& cpath) : first(0), last(0) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
     }
 
@@ -454,5 +454,5 @@
     template <typename CPath>
     ListPath& operator=(const CPath& cpath) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
       return *this;
     }
@@ -764,5 +764,5 @@
     template <typename CPath>
     StaticPath(const CPath& cpath) : arcs(0) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
     }
 
@@ -780,5 +780,5 @@
     template <typename CPath>
     StaticPath& operator=(const CPath& cpath) {
-      pathCopy(cpath, *this);
+      copyPath(*this, cpath);
       return *this;
     }
@@ -929,55 +929,55 @@
     };
 
-    template <typename From, typename To,
-              bool buildEnable = BuildTagIndicator<To>::value>
+    template <typename Target, typename Source,
+              bool buildEnable = BuildTagIndicator<Target>::value>
     struct PathCopySelectorForward {
-      static void copy(const From& from, To& to) {
-        to.clear();
-        for (typename From::ArcIt it(from); it != INVALID; ++it) {
-          to.addBack(it);
+      static void copy(Target& target, const Source& source) {
+        target.clear();
+        for (typename Source::ArcIt it(source); it != INVALID; ++it) {
+          target.addBack(it);
         }
       }
     };
 
-    template <typename From, typename To>
-    struct PathCopySelectorForward<From, To, true> {
-      static void copy(const From& from, To& to) {
-        to.clear();
-        to.build(from);
-      }
-    };
-
-    template <typename From, typename To,
-              bool buildEnable = BuildTagIndicator<To>::value>
+    template <typename Target, typename Source>
+    struct PathCopySelectorForward<Target, Source, true> {
+      static void copy(Target& target, const Source& source) {
+        target.clear();
+        target.build(source);
+      }
+    };
+
+    template <typename Target, typename Source,
+              bool buildEnable = BuildTagIndicator<Target>::value>
     struct PathCopySelectorBackward {
-      static void copy(const From& from, To& to) {
-        to.clear();
-        for (typename From::RevArcIt it(from); it != INVALID; ++it) {
-          to.addFront(it);
+      static void copy(Target& target, const Source& source) {
+        target.clear();
+        for (typename Source::RevArcIt it(source); it != INVALID; ++it) {
+          target.addFront(it);
         }
       }
     };
 
-    template <typename From, typename To>
-    struct PathCopySelectorBackward<From, To, true> {
-      static void copy(const From& from, To& to) {
-        to.clear();
-        to.buildRev(from);
+    template <typename Target, typename Source>
+    struct PathCopySelectorBackward<Target, Source, true> {
+      static void copy(Target& target, const Source& source) {
+        target.clear();
+        target.buildRev(source);
       }
     };
 
     
-    template <typename From, typename To,
-              bool revEnable = RevPathTagIndicator<From>::value>
+    template <typename Target, typename Source,
+              bool revEnable = RevPathTagIndicator<Source>::value>
     struct PathCopySelector {
-      static void copy(const From& from, To& to) {
-        PathCopySelectorForward<From, To>::copy(from, to);
+      static void copy(Target& target, const Source& source) {
+        PathCopySelectorForward<Target, Source>::copy(target, source);
       }      
     };
 
-    template <typename From, typename To>
-    struct PathCopySelector<From, To, true> {
-      static void copy(const From& from, To& to) {
-        PathCopySelectorBackward<From, To>::copy(from, to);
+    template <typename Target, typename Source>
+    struct PathCopySelector<Target, Source, true> {
+      static void copy(Target& target, const Source& source) {
+        PathCopySelectorBackward<Target, Source>::copy(target, source);
       }      
     };
@@ -988,17 +988,9 @@
   /// \brief Make a copy of a path.
   ///
-  /// This function makes a copy of a path.
-  template <typename From, typename To>
-  void pathCopy(const From& from, To& to) {
-    checkConcept<concepts::PathDumper<typename From::Digraph>, From>();
-    _path_bits::PathCopySelector<From, To>::copy(from, to);
-  }
-
-  /// \brief Deprecated version of \ref pathCopy().
-  ///
-  /// Deprecated version of \ref pathCopy() (only for reverse compatibility).
-  template <typename To, typename From>
-  void copyPath(To& to, const From& from) {
-    pathCopy(from, to);
+  ///  This function makes a copy of a path.
+  template <typename Target, typename Source>
+  void copyPath(Target& target, const Source& source) {
+    checkConcept<concepts::PathDumper<typename Source::Digraph>, Source>();
+    _path_bits::PathCopySelector<Target, Source>::copy(target, source);
   }
 
@@ -1024,18 +1016,16 @@
   /// \brief The source of a path
   ///
-  /// This function returns the source node of the given path.
-  /// If the path is empty, then it returns \c INVALID.
+  /// This function returns the source of the given path.
   template <typename Digraph, typename Path>
   typename Digraph::Node pathSource(const Digraph& digraph, const Path& path) {
-    return path.empty() ? INVALID : digraph.source(path.front());
+    return digraph.source(path.front());
   }
 
   /// \brief The target of a path
   ///
-  /// This function returns the target node of the given path.
-  /// If the path is empty, then it returns \c INVALID.
+  /// This function returns the target of the given path.
   template <typename Digraph, typename Path>
   typename Digraph::Node pathTarget(const Digraph& digraph, const Path& path) {
-    return path.empty() ? INVALID : digraph.target(path.back());
+    return digraph.target(path.back());
   }
 
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 835)
+++ lemon/preflow.h	(revision 688)
@@ -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,8 +96,7 @@
   /// 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 \ref clrs01algorithms,
-  /// \ref amo93networkflows, \ref 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{e})\f$.
@@ -266,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().
@@ -380,9 +372,8 @@
     }
 
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    Preflow& tolerance(const Tolerance& tolerance) {
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
+    Preflow& tolerance(const Tolerance& tolerance) const {
       _tolerance = tolerance;
       return *this;
@@ -391,8 +382,7 @@
     /// \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;
+      return tolerance;
     }
 
@@ -400,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/radix_heap.h
===================================================================
--- lemon/radix_heap.h	(revision 758)
+++ 	(revision )
@@ -1,438 +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_RADIX_HEAP_H
-#define LEMON_RADIX_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Radix heap implementation.
-
-#include <vector>
-#include <lemon/error.h>
-
-namespace lemon {
-
-
-  /// \ingroup heaps
-  ///
-  /// \brief Radix heap data structure.
-  ///
-  /// 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.
-  ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  template <typename IM>
-  class RadixHeap {
-
-  public:
-
-    /// Type of the item-int map.
-    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.
-    /// \see RadixHeap
-    class PriorityUnderflowError : public Exception {
-    public:
-      virtual const char* what() const throw() {
-        return "lemon::RadixHeap::PriorityUnderflowError";
-      }
-    };
-
-    /// \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:
-
-    struct RadixItem {
-      int prev, next, box;
-      Item item;
-      int prio;
-      RadixItem(Item _item, int _prio) : item(_item), prio(_prio) {}
-    };
-
-    struct RadixBox {
-      int first;
-      int min, size;
-      RadixBox(int _min, int _size) : first(-1), min(_min), size(_size) {}
-    };
-
-    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)) {
-        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)) {
-        extend();
-      }
-    }
-
-  private:
-
-    bool upper(int box, Prio pr) {
-      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
-    void remove(int index) {
-      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
-    void insert(int box, int index) {
-      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
-    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;
-      remove(index);
-      int box = findUp(_data[index].box, _data[index].prio);
-      insert(box, index);
-    }
-
-    // Find up the proper box for the item with the given priority
-    int findUp(int start, int pr) {
-      while (lower(start, pr)) {
-        if (++start == int(_boxes.size())) {
-          extend();
-        }
-      }
-      return start;
-    }
-
-    // Move an item down into the proper box
-    void bubbleDown(int index) {
-      if (!upper(_data[index].box, _data[index].prio)) return;
-      remove(index);
-      int box = findDown(_data[index].box, _data[index].prio);
-      insert(box, index);
-    }
-
-    // Find down the proper box for the item with the given priority
-    int findDown(int start, int pr) {
-      while (upper(start, pr)) {
-        if (--start < 0) throw PriorityUnderflowError();
-      }
-      return start;
-    }
-
-    // Find the first non-empty box
-    int findFirst() {
-      int first = 0;
-      while (_boxes[first].first == -1) ++first;
-      return first;
-    }
-
-    // Gives back the minimum priority of the given 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;
-      }
-      return min;
-    }
-
-    // Rearrange the items of the heap and make the first box non-empty
-    void moveDown() {
-      int box = findFirst();
-      if (box == 0) return;
-      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;
-      while (curr != -1) {
-        next = _data[curr].next;
-        bubbleDown(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;
-        } else {
-          _boxes[_data[index].box].first = index;
-        }
-        if (_data[index].next != -1) {
-          _data[_data[index].next].prev = index;
-        }
-        _iim[_data[index].item] = index;
-      }
-      _data.pop_back();
-    }
-
-  public:
-
-    /// \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.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
-    void push(const Item &i, const Prio &p) {
-      int n = _data.size();
-      _iim.set(i, n);
-      _data.push_back(RadixItem(i, p));
-      while (lower(_boxes.size() - 1, p)) {
-        extend();
-      }
-      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.
-    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.
-    Prio prio() const {
-      const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].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() {
-      moveDown();
-      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.
-    void erase(const Item &i) {
-      int index = _iim[i];
-      _iim[i] = POST_HEAP;
-      remove(index);
-      relocateLast(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.
-    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.
-    /// \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];
-      if( idx < 0 ) {
-        push(i, p);
-      }
-      else if( p >= _data[idx].prio ) {
-        _data[idx].prio = p;
-        bubbleUp(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.
-    /// \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.
-    /// \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.
-    /// \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;
-      }
-    }
-
-  }; // class RadixHeap
-
-} // namespace lemon
-
-#endif // LEMON_RADIX_HEAP_H
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 834)
+++ lemon/smart_graph.h	(revision 664)
@@ -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()
       {
@@ -500,5 +509,5 @@
     }
 
-    static void next(Node& node) {
+    void next(Node& node) const {
       --node._id;
     }
@@ -508,5 +517,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc._id;
     }
@@ -516,5 +525,5 @@
     }
 
-    static void next(Edge& arc) {
+    void next(Edge& arc) const {
       --arc._id;
     }
@@ -613,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 &) {}
 
@@ -645,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:
@@ -754,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
     {
@@ -781,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()
       {
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 793)
+++ lemon/soplex.cc	(revision 623)
@@ -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) {
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 793)
+++ lemon/soplex.h	(revision 623)
@@ -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 834)
+++ 	(revision )
@@ -1,476 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * 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 670)
+++ lemon/suurballe.h	(revision 843)
@@ -46,6 +46,6 @@
   /// Note that this problem is a special case of the \ref min_cost_flow
   /// "minimum cost flow problem". This implementation is actually an
-  /// efficient specialized version of the \ref CapacityScaling
-  /// "Successive Shortest Path" algorithm directly for this problem.
+  /// efficient specialized version of the 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
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 833)
+++ lemon/time_measure.h	(revision 631)
@@ -376,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
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 833)
+++ lemon/unionfind.h	(revision 606)
@@ -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
