Changes in / [607:49a39bae067c:605:f53d641aa967] in lemon

Files:

• doc/groups.dox (modified) (33 diffs)
• doc/mainpage.dox (modified) (1 diff)
• lemon/adaptors.h (modified) (11 diffs)
• lemon/bin_heap.h (modified) (21 diffs)
• lemon/bits/edge_set_extender.h (modified) (6 diffs)
• lemon/circulation.h (modified) (5 diffs)
• lemon/concepts/graph.h (modified) (1 diff)
• lemon/concepts/graph_components.h (modified) (38 diffs)
• lemon/concepts/heap.h (modified) (5 diffs)
• lemon/concepts/path.h (modified) (3 diffs)
• lemon/connectivity.h (modified) (9 diffs)
• lemon/core.h (modified) (8 diffs)
• lemon/dijkstra.h (modified) (13 diffs)
• lemon/edge_set.h (modified) (8 diffs)
• lemon/elevator.h (modified) (10 diffs)
• lemon/euler.h (modified) (5 diffs)
• lemon/graph_to_eps.h (modified) (8 diffs)
• lemon/grid_graph.h (modified) (1 diff)
• lemon/hao_orlin.h (modified) (2 diffs)
• lemon/hypercube_graph.h (modified) (1 diff)
• lemon/lgf_reader.h (modified) (3 diffs)
• lemon/lgf_writer.h (modified) (3 diffs)
• lemon/list_graph.h (modified) (4 diffs)
• lemon/maps.h (modified) (77 diffs)
• lemon/max_matching.h (modified) (6 diffs)
• lemon/min_cost_arborescence.h (modified) (8 diffs)
• lemon/path.h (modified) (13 diffs)
• lemon/preflow.h (modified) (9 diffs)
• lemon/radix_sort.h (modified) (2 diffs)
• lemon/random.h (modified) (3 diffs)
• lemon/smart_graph.h (modified) (4 diffs)
• lemon/suurballe.h (modified) (5 diffs)
• lemon/unionfind.h (modified) (7 diffs)

doc/groups.dox

@@ -21 +21 @@
 /**
 @defgroup datas Data Structures
-This group contains the several data structures implemented in LEMON.
+This group describes the several data structures implemented in LEMON.
 */
 
@@ -143 +143 @@
 \brief Graph types between real graphs and graph adaptors.
 
-This group contains some graph types between real graphs and graph adaptors.
+This group describes some graph types between real graphs and graph adaptors.
 These classes wrap graphs to give new functionality as the adaptors do it.
 On the other hand they are not light-weight structures as the adaptors.
@@ -153 +153 @@
 \brief Map structures implemented in LEMON.
 
-This group contains the map structures implemented in LEMON.
+This group describes the map structures implemented in LEMON.
 
 LEMON provides several special purpose maps and map adaptors that e.g. combine
@@ -166 +166 @@
 \brief Special graph-related maps.
 
-This group contains maps that are specifically designed to assign
+This group describes maps that are specifically designed to assign
 values to the nodes and arcs/edges of graphs.
 
@@ -178 +178 @@
 \brief Tools to create new maps from existing ones
 
-This group contains map adaptors that are used to create "implicit"
+This group describes map adaptors that are used to create "implicit"
 maps from other maps.
 
@@ -241 +241 @@
 \brief Two dimensional data storages implemented in LEMON.
 
-This group contains two dimensional data storages implemented in LEMON.
+This group describes two dimensional data storages implemented in LEMON.
 */
 
@@ -249 +249 @@
 \brief %Path structures implemented in LEMON.
 
-This group contains the path structures implemented in LEMON.
+This group describes the path structures implemented in LEMON.
 
 LEMON provides flexible data structures to work with paths.
@@ -265 +265 @@
 \brief Auxiliary data structures implemented in LEMON.
 
-This group contains some data structures implemented in LEMON in
+This group describes some data structures implemented in LEMON in
 order to make it easier to implement combinatorial algorithms.
 */
@@ -271 +271 @@
 /**
 @defgroup algs Algorithms
-\brief This group contains the several algorithms
+\brief This group describes the several algorithms
 implemented in LEMON.
 
-This group contains the several algorithms
+This group describes the several algorithms
 implemented in LEMON.
 */
@@ -283 +283 @@
 \brief Common graph search algorithms.
 
-This group contains the common graph search algorithms, namely
+This group describes the common graph search algorithms, namely
 \e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
 */
@@ -292 +292 @@
 \brief Algorithms for finding shortest paths.
 
-This group contains the algorithms for finding shortest paths in digraphs.
+This group describes the algorithms for finding shortest paths in digraphs.
 
  - \ref Dijkstra algorithm for finding shortest paths from a source node
@@ -313 +313 @@
 \brief Algorithms for finding maximum flows.
 
-This group contains the algorithms for finding maximum flows and
+This group describes the algorithms for finding maximum flows and
 feasible circulations.
 
@@ -346 +346 @@
 \brief Algorithms for finding minimum cost flows and circulations.
 
-This group contains the algorithms for finding minimum cost flows and
+This group describes the algorithms for finding minimum cost flows and
 circulations.
 
@@ -383 +383 @@
 \brief Algorithms for finding minimum cut in graphs.
 
-This group contains the algorithms for finding minimum cut in graphs.
+This group describes the algorithms for finding minimum cut in graphs.
 
 The \e minimum \e cut \e problem is to find a non-empty and non-complete
@@ -400 +400 @@
 - \ref NagamochiIbaraki "Nagamochi-Ibaraki algorithm" for
   calculating minimum cut in undirected graphs.
-- \ref GomoryHu "Gomory-Hu tree computation" for calculating
+- \ref GomoryHuTree "Gomory-Hu tree computation" for calculating
   all-pairs minimum cut in undirected graphs.
 
@@ -412 +412 @@
 \brief Algorithms for discovering the graph properties
 
-This group contains the algorithms for discovering the graph properties
+This group describes the algorithms for discovering the graph properties
 like connectivity, bipartiteness, euler property, simplicity etc.
 
@@ -424 +424 @@
 \brief Algorithms for planarity checking, embedding and drawing
 
-This group contains the algorithms for planarity checking,
+This group describes the algorithms for planarity checking,
 embedding and drawing.
 
@@ -475 +475 @@
 \brief Algorithms for finding a minimum cost spanning tree in a graph.
 
-This group contains the algorithms for finding a minimum cost spanning
+This group describes the algorithms for finding a minimum cost spanning
 tree in a graph.
 */
@@ -484 +484 @@
 \brief Auxiliary algorithms implemented in LEMON.
 
-This group contains some algorithms implemented in LEMON
+This group describes some algorithms implemented in LEMON
 in order to make it easier to implement complex algorithms.
 */
@@ -493 +493 @@
 \brief Approximation algorithms.
 
-This group contains the approximation and heuristic algorithms
+This group describes the approximation and heuristic algorithms
 implemented in LEMON.
 */
@@ -499 +499 @@
 /**
 @defgroup gen_opt_group General Optimization Tools
-\brief This group contains some general optimization frameworks
+\brief This group describes some general optimization frameworks
 implemented in LEMON.
 
-This group contains some general optimization frameworks
+This group describes some general optimization frameworks
 implemented in LEMON.
 */
@@ -511 +511 @@
 \brief Lp and Mip solver interfaces for LEMON.
 
-This group contains Lp and Mip solver interfaces for LEMON. The
+This group describes Lp and Mip solver interfaces for LEMON. The
 various LP solvers could be used in the same manner with this
 interface.
@@ -530 +530 @@
 \brief Metaheuristics for LEMON library.
 
-This group contains some metaheuristic optimization tools.
+This group describes some metaheuristic optimization tools.
 */
 
@@ -545 +545 @@
 \brief Simple basic graph utilities.
 
-This group contains some simple basic graph utilities.
+This group describes some simple basic graph utilities.
 */
 
@@ -553 +553 @@
 \brief Tools for development, debugging and testing.
 
-This group contains several useful tools for development,
+This group describes several useful tools for development,
 debugging and testing.
 */
@@ -562 +562 @@
 \brief Simple tools for measuring the performance of algorithms.
 
-This group contains simple tools for measuring the performance
+This group describes simple tools for measuring the performance
 of algorithms.
 */
@@ -571 +571 @@
 \brief Exceptions defined in LEMON.
 
-This group contains the exceptions defined in LEMON.
+This group describes the exceptions defined in LEMON.
 */
 
@@ -578 +578 @@
 \brief Graph Input-Output methods
 
-This group contains the tools for importing and exporting graphs
+This group describes the tools for importing and exporting graphs
 and graph related data. Now it supports the \ref lgf-format
 "LEMON Graph Format", the \c DIMACS format and the encapsulated
@@ -589 +589 @@
 \brief Reading and writing LEMON Graph Format.
 
-This group contains methods for reading and writing
+This group describes methods for reading and writing
 \ref lgf-format "LEMON Graph Format".
 */
@@ -598 +598 @@
 \brief General \c EPS drawer and graph exporter
 
-This group contains general \c EPS drawing methods and special
+This group describes general \c EPS drawing methods and special
 graph exporting tools.
 */
@@ -622 +622 @@
 \brief Skeleton classes and concept checking classes
 
-This group contains the data/algorithm skeletons and concept checking
+This group describes the data/algorithm skeletons and concept checking
 classes implemented in LEMON.
 
@@ -652 +652 @@
 \brief Skeleton and concept checking classes for graph structures
 
-This group contains the skeletons and concept checking classes of LEMON's
+This group describes the skeletons and concept checking classes of LEMON's
 graph structures and helper classes used to implement these.
 */
@@ -661 +661 @@
 \brief Skeleton and concept checking classes for maps
 
-This group contains the skeletons and concept checking classes of maps.
+This group describes the skeletons and concept checking classes of maps.
 */
 

doc/mainpage.dox

@@ -46 +46 @@
 "Quick Tour to LEMON" which will guide you along.
 
-If you already feel like using our library, see the
-<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.
+If you already feel like using our library, see the page that tells you
+\ref getstart "How to start using LEMON".
+
+If you
+want to see how LEMON works, see
+some \ref demoprograms "demo programs".
 
 If you know what you are looking for then try to find it under the
-<a class="el" href="modules.html">Modules</a> section.
+<a class="el" href="modules.html">Modules</a>
+section.
 
 If you are a user of the old (0.x) series of LEMON, please check out the

lemon/adaptors.h

@@ -2255 +2255 @@
     /// This map adaptor class adapts two arc maps of the underlying
     /// digraph to get an arc map of the undirected graph.
-    /// Its value type is inherited from the first arc map type (\c FW).
-    /// \tparam FW The type of the "foward" arc map.
-    /// \tparam BK The type of the "backward" arc map.
-    template <typename FW, typename BK>
+    /// Its value type is inherited from the first arc map type
+    /// (\c %ForwardMap).
+    template <typename ForwardMap, typename BackwardMap>
     class CombinedArcMap {
     public:
@@ -2265 +2264 @@
       typedef typename Parent::Arc Key;
       /// The value type of the map
-      typedef typename FW::Value Value;
-
-      typedef typename MapTraits<FW>::ReferenceMapTag ReferenceMapTag;
-
-      typedef typename MapTraits<FW>::ReturnValue ReturnValue;
-      typedef typename MapTraits<FW>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<FW>::ReturnValue Reference;
-      typedef typename MapTraits<FW>::ConstReturnValue ConstReference;
+      typedef typename ForwardMap::Value Value;
+
+      typedef typename MapTraits<ForwardMap>::ReferenceMapTag ReferenceMapTag;
+
+      typedef typename MapTraits<ForwardMap>::ReturnValue ReturnValue;
+      typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<ForwardMap>::ReturnValue Reference;
+      typedef typename MapTraits<ForwardMap>::ConstReturnValue ConstReference;
 
       /// Constructor
-      CombinedArcMap(FW& forward, BK& backward)
+      CombinedArcMap(ForwardMap& forward, BackwardMap& backward)
         : _forward(&forward), _backward(&backward) {}
 
@@ -2307 +2306 @@
     protected:
 
-      FW* _forward;
-      BK* _backward;
+      ForwardMap* _forward;
+      BackwardMap* _backward;
 
     };
@@ -2315 +2314 @@
     ///
     /// This function just returns a combined arc map.
-    template <typename FW, typename BK>
-    static CombinedArcMap<FW, BK>
-    combinedArcMap(FW& forward, BK& backward) {
-      return CombinedArcMap<FW, BK>(forward, backward);
-    }
-
-    template <typename FW, typename BK>
-    static CombinedArcMap<const FW, BK>
-    combinedArcMap(const FW& forward, BK& backward) {
-      return CombinedArcMap<const FW, BK>(forward, backward);
-    }
-
-    template <typename FW, typename BK>
-    static CombinedArcMap<FW, const BK>
-    combinedArcMap(FW& forward, const BK& backward) {
-      return CombinedArcMap<FW, const BK>(forward, backward);
-    }
-
-    template <typename FW, typename BK>
-    static CombinedArcMap<const FW, const BK>
-    combinedArcMap(const FW& forward, const BK& backward) {
-      return CombinedArcMap<const FW, const BK>(forward, backward);
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<ForwardMap, BackwardMap>
+    combinedArcMap(ForwardMap& forward, BackwardMap& backward) {
+      return CombinedArcMap<ForwardMap, BackwardMap>(forward, backward);
+    }
+
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<const ForwardMap, BackwardMap>
+    combinedArcMap(const ForwardMap& forward, BackwardMap& backward) {
+      return CombinedArcMap<const ForwardMap,
+        BackwardMap>(forward, backward);
+    }
+
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<ForwardMap, const BackwardMap>
+    combinedArcMap(ForwardMap& forward, const BackwardMap& backward) {
+      return CombinedArcMap<ForwardMap,
+        const BackwardMap>(forward, backward);
+    }
+
+    template <typename ForwardMap, typename BackwardMap>
+    static CombinedArcMap<const ForwardMap, const BackwardMap>
+    combinedArcMap(const ForwardMap& forward, const BackwardMap& backward) {
+      return CombinedArcMap<const ForwardMap,
+        const BackwardMap>(forward, backward);
     }
 
@@ -3405 +3407 @@
     /// This map adaptor class adapts two node maps of the original digraph
     /// to get a node map of the split digraph.
-    /// Its value type is inherited from the first node map type (\c IN).
-    /// \tparam IN The type of the node map for the in-nodes. 
-    /// \tparam OUT The type of the node map for the out-nodes.
-    template <typename IN, typename OUT>
+    /// Its value type is inherited from the first node map type
+    /// (\c InNodeMap).
+    template <typename InNodeMap, typename OutNodeMap>
     class CombinedNodeMap {
     public:
@@ -3415 +3416 @@
       typedef Node Key;
       /// The value type of the map
-      typedef typename IN::Value Value;
-
-      typedef typename MapTraits<IN>::ReferenceMapTag ReferenceMapTag;
-      typedef typename MapTraits<IN>::ReturnValue ReturnValue;
-      typedef typename MapTraits<IN>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<IN>::ReturnValue Reference;
-      typedef typename MapTraits<IN>::ConstReturnValue ConstReference;
+      typedef typename InNodeMap::Value Value;
+
+      typedef typename MapTraits<InNodeMap>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<InNodeMap>::ReturnValue ReturnValue;
+      typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<InNodeMap>::ReturnValue Reference;
+      typedef typename MapTraits<InNodeMap>::ConstReturnValue ConstReference;
 
       /// Constructor
-      CombinedNodeMap(IN& in_map, OUT& out_map)
+      CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map)
         : _in_map(in_map), _out_map(out_map) {}
 
@@ -3456 +3457 @@
     private:
 
-      IN& _in_map;
-      OUT& _out_map;
+      InNodeMap& _in_map;
+      OutNodeMap& _out_map;
 
     };
@@ -3465 +3466 @@
     ///
     /// This function just returns a combined node map.
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<IN, OUT>
-    combinedNodeMap(IN& in_map, OUT& out_map) {
-      return CombinedNodeMap<IN, OUT>(in_map, out_map);
-    }
-
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<const IN, OUT>
-    combinedNodeMap(const IN& in_map, OUT& out_map) {
-      return CombinedNodeMap<const IN, OUT>(in_map, out_map);
-    }
-
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<IN, const OUT>
-    combinedNodeMap(IN& in_map, const OUT& out_map) {
-      return CombinedNodeMap<IN, const OUT>(in_map, out_map);
-    }
-
-    template <typename IN, typename OUT>
-    static CombinedNodeMap<const IN, const OUT>
-    combinedNodeMap(const IN& in_map, const OUT& out_map) {
-      return CombinedNodeMap<const IN, const OUT>(in_map, out_map);
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<InNodeMap, OutNodeMap>
+    combinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map) {
+      return CombinedNodeMap<InNodeMap, OutNodeMap>(in_map, out_map);
+    }
+
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<const InNodeMap, OutNodeMap>
+    combinedNodeMap(const InNodeMap& in_map, OutNodeMap& out_map) {
+      return CombinedNodeMap<const InNodeMap, OutNodeMap>(in_map, out_map);
+    }
+
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<InNodeMap, const OutNodeMap>
+    combinedNodeMap(InNodeMap& in_map, const OutNodeMap& out_map) {
+      return CombinedNodeMap<InNodeMap, const OutNodeMap>(in_map, out_map);
+    }
+
+    template <typename InNodeMap, typename OutNodeMap>
+    static CombinedNodeMap<const InNodeMap, const OutNodeMap>
+    combinedNodeMap(const InNodeMap& in_map, const OutNodeMap& out_map) {
+      return CombinedNodeMap<const InNodeMap,
+        const OutNodeMap>(in_map, out_map);
     }
 
@@ -3494 +3496 @@
     /// This map adaptor class adapts an arc map and a node map of the
     /// original digraph to get an arc map of the split digraph.
-    /// Its value type is inherited from the original arc map type (\c AM).
-    /// \tparam AM The type of the arc map.
-    /// \tparam NM the type of the node map.
-    template <typename AM, typename NM>
+    /// Its value type is inherited from the original arc map type
+    /// (\c ArcMap).
+    template <typename ArcMap, typename NodeMap>
     class CombinedArcMap {
     public:
@@ -3504 +3505 @@
       typedef Arc Key;
       /// The value type of the map
-      typedef typename AM::Value Value;
-
-      typedef typename MapTraits<AM>::ReferenceMapTag ReferenceMapTag;
-      typedef typename MapTraits<AM>::ReturnValue ReturnValue;
-      typedef typename MapTraits<AM>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<AM>::ReturnValue Reference;
-      typedef typename MapTraits<AM>::ConstReturnValue ConstReference;
+      typedef typename ArcMap::Value Value;
+
+      typedef typename MapTraits<ArcMap>::ReferenceMapTag ReferenceMapTag;
+      typedef typename MapTraits<ArcMap>::ReturnValue ReturnValue;
+      typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReturnValue;
+      typedef typename MapTraits<ArcMap>::ReturnValue Reference;
+      typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReference;
 
       /// Constructor
-      CombinedArcMap(AM& arc_map, NM& node_map)
+      CombinedArcMap(ArcMap& arc_map, NodeMap& node_map)
         : _arc_map(arc_map), _node_map(node_map) {}
 
@@ -3544 +3545 @@
 
     private:
-
-      AM& _arc_map;
-      NM& _node_map;
-
+      ArcMap& _arc_map;
+      NodeMap& _node_map;
     };
 

lemon/bin_heap.h

@@ -34 +34 @@
   ///\brief A Binary Heap implementation.
   ///
-  ///This class implements the \e binary \e heap data structure. 
-  /// 
-  ///A \e heap is a data structure for storing items with specified values
-  ///called \e priorities in such a way that finding the item with minimum
-  ///priority is efficient. \c Comp specifies the ordering of the priorities.
-  ///In a heap one can change the priority of an item, add or erase an
-  ///item, etc.
+  ///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 Compare specifies the ordering of the priorities. In a heap
+  ///one can change the priority of an item, add or erase an item, etc.
   ///
-  ///\tparam PR Type of the priority of the items.
-  ///\tparam IM A read and writable item map with int values, used internally
+  ///\tparam _Prio Type of the priority of the items.
+  ///\tparam _ItemIntMap A read and writable Item int map, 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>.
+  ///\tparam _Compare A class for the ordering of the priorities. The
+  ///default is \c std::less<_Prio>.
   ///
   ///\sa FibHeap
   ///\sa Dijkstra
-  template <typename PR, typename IM, typename Comp = std::less<PR> >
+  template <typename _Prio, typename _ItemIntMap,
+            typename _Compare = std::less<_Prio> >
   class BinHeap {
 
   public:
     ///\e
-    typedef IM ItemIntMap;
-    ///\e
-    typedef PR Prio;
+    typedef _ItemIntMap ItemIntMap;
+    ///\e
+    typedef _Prio Prio;
     ///\e
     typedef typename ItemIntMap::Key Item;
@@ -63 +62 @@
     typedef std::pair<Item,Prio> Pair;
     ///\e
-    typedef Comp Compare;
+    typedef _Compare Compare;
 
     /// \brief Type to represent the items states.
@@ -71 +70 @@
     /// heap's point of view, but may be useful to the user.
     ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    /// The ItemIntMap \e should be initialized in such way that it maps
+    /// PRE_HEAP (-1) to any element to be put in the heap...
     enum State {
-      IN_HEAP = 0,    ///< \e
-      PRE_HEAP = -1,  ///< \e
-      POST_HEAP = -2  ///< \e
+      IN_HEAP = 0,
+      PRE_HEAP = -1,
+      POST_HEAP = -2
     };
 
   private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
+    std::vector<Pair> data;
+    Compare comp;
+    ItemIntMap &iim;
 
   public:
@@ -88 +87 @@
     ///
     /// 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 The constructor.
-    ///
-    /// The constructor.
-    /// \param map should be given to the constructor, since it is used
+    /// \param _iim 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) {}
+    explicit BinHeap(ItemIntMap &_iim) : iim(_iim) {}
+
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param _iim 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 &_iim, const Compare &_comp)
+      : iim(_iim), comp(_comp) {}
 
 
@@ -108 +107 @@
     ///
     /// \brief Returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
+    int size() const { return data.size(); }
 
     /// \brief Checks if the heap stores no items.
     ///
     /// Returns \c true if and only if the heap stores no items.
-    bool empty() const { return _data.empty(); }
+    bool empty() const { return data.empty(); }
 
     /// \brief Make empty this heap.
@@ -122 +121 @@
     /// each item to \c PRE_HEAP.
     void clear() {
-      _data.clear();
+      data.clear();
     }
 
@@ -130 +129 @@
     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);
+      return comp(p1.second, p2.second);
     }
 
     int bubble_up(int hole, Pair p) {
       int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
+      while( hole>0 && less(p,data[par]) ) {
+        move(data[par],hole);
         hole = par;
         par = parent(hole);
@@ -147 +146 @@
       int child = second_child(hole);
       while(child < length) {
-        if( less(_data[child-1], _data[child]) ) {
+        if( less(data[child-1], data[child]) ) {
           --child;
         }
-        if( !less(_data[child], p) )
+        if( !less(data[child], p) )
           goto ok;
-        move(_data[child], hole);
+        move(data[child], hole);
         hole = child;
         child = second_child(hole);
       }
       child--;
-      if( child<length && less(_data[child], p) ) {
-        move(_data[child], hole);
+      if( child<length && less(data[child], p) ) {
+        move(data[child], hole);
         hole=child;
       }
@@ -167 +166 @@
 
     void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
+      data[i] = p;
+      iim.set(p.first, i);
     }
 
@@ -177 +176 @@
     /// \param p The pair to insert.
     void push(const Pair &p) {
-      int n = _data.size();
-      _data.resize(n+1);
+      int n = data.size();
+      data.resize(n+1);
       bubble_up(n, p);
     }
@@ -195 +194 @@
     /// \pre The heap must be nonempty.
     Item top() const {
-      return _data[0].first;
+      return data[0].first;
     }
 
@@ -203 +202 @@
     /// \pre The heap must be nonempty.
     Prio prio() const {
-      return _data[0].second;
+      return data[0].second;
     }
 
@@ -212 +211 @@
     /// \pre The heap must be non-empty.
     void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
+      int n = data.size()-1;
+      iim.set(data[0].first, POST_HEAP);
       if (n > 0) {
-        bubble_down(0, _data[n], n);
-      }
-      _data.pop_back();
+        bubble_down(0, data[n], n);
+      }
+      data.pop_back();
     }
 
@@ -226 +225 @@
     /// \pre The item should 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);
+      int h = iim[i];
+      int n = data.size()-1;
+      iim.set(data[h].first, POST_HEAP);
       if( h < n ) {
-        if ( bubble_up(h, _data[n]) == h) {
-          bubble_down(h, _data[n], n);
+        if ( bubble_up(h, data[n]) == h) {
+          bubble_down(h, data[n], n);
         }
       }
-      _data.pop_back();
+      data.pop_back();
     }
 
@@ -241 +240 @@
     ///
     /// This function returns the priority of item \c i.
-    /// \param i The item.
     /// \pre \c i must be in the heap.
+    /// \param i The item.
     Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].second;
+      int idx = iim[i];
+      return data[idx].second;
     }
 
@@ -256 +255 @@
     /// \param p The priority.
     void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
+      int idx = iim[i];
       if( idx < 0 ) {
         push(i,p);
       }
-      else if( _comp(p, _data[idx].second) ) {
+      else if( comp(p, data[idx].second) ) {
         bubble_up(idx, Pair(i,p));
       }
       else {
-        bubble_down(idx, Pair(i,p), _data.size());
+        bubble_down(idx, Pair(i,p), data.size());
       }
     }
@@ -271 +270 @@
     ///
     /// This method decreases the priority of item \c i to \c p.
-    /// \param i The item.
-    /// \param p The priority.
     /// \pre \c i must be stored in the heap with priority at least \c
     /// p relative to \c Compare.
+    /// \param i The item.
+    /// \param p The priority.
     void decrease(const Item &i, const Prio &p) {
-      int idx = _iim[i];
+      int idx = iim[i];
       bubble_up(idx, Pair(i,p));
     }
@@ -283 +282 @@
     ///
     /// This method sets the priority of item \c i to \c p.
-    /// \param i The item.
-    /// \param p The priority.
     /// \pre \c i must be stored in the heap with priority at most \c
     /// p relative to \c Compare.
+    /// \param i The item.
+    /// \param p The priority.
     void increase(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubble_down(idx, Pair(i,p), _data.size());
+      int idx = iim[i];
+      bubble_down(idx, Pair(i,p), data.size());
     }
 
@@ -301 +300 @@
     /// \param i The item.
     State state(const Item &i) const {
-      int s = _iim[i];
+      int s = iim[i];
       if( s>=0 )
         s=0;
@@ -321 +320 @@
           erase(i);
         }
-        _iim[i] = st;
+        iim[i] = st;
         break;
       case IN_HEAP:
@@ -335 +334 @@
     /// with the same prioriority as prevoiusly the \c i item.
     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;
+      int idx = iim[i];
+      iim.set(i, iim[j]);
+      iim.set(j, idx);
+      data[idx].first = j;
     }
 

lemon/bits/edge_set_extender.h

@@ -25 +25 @@
 #include <lemon/bits/map_extender.h>
 
-//\ingroup digraphbits
-//\file
-//\brief Extenders for the arc set types
+///\ingroup digraphbits
+///\file
+///\brief Extenders for the arc set types
 namespace lemon {
 
-  // \ingroup digraphbits
-  //
-  // \brief Extender for the ArcSets
+  /// \ingroup digraphbits
+  ///
+  /// \brief Extender for the ArcSets
   template <typename Base>
   class ArcSetExtender : public Base {
@@ -73 +73 @@
     // Alteration notifier extensions
 
-    // The arc observer registry.
+    /// The arc observer registry.
     typedef AlterationNotifier<ArcSetExtender, Arc> ArcNotifier;
 
@@ -84 +84 @@
     using Parent::notifier;
 
-    // Gives back the arc alteration notifier.
+    /// \brief Gives back the arc alteration notifier.
+    ///
+    /// Gives back the arc alteration notifier.
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
@@ -184 +186 @@
     };
 
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the source in this case) of the iterator
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the source in this case) of the iterator
     Node baseNode(const OutArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
     }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the target in this case) of the
-    // iterator
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the target in this case) of the
+    /// iterator
     Node runningNode(const OutArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
     }
 
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the target in this case) of the iterator
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the target in this case) of the iterator
     Node baseNode(const InArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
     }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the source in this case) of the
-    // iterator
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the source in this case) of the
+    /// iterator
     Node runningNode(const InArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
@@ -270 +272 @@
 
 
-  // \ingroup digraphbits
-  //
-  // \brief Extender for the EdgeSets
+  /// \ingroup digraphbits
+  ///
+  /// \brief Extender for the EdgeSets
   template <typename Base>
   class EdgeSetExtender : public Base {
@@ -491 +493 @@
     };
 
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the source in this case) of the iterator
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the source in this case) of the iterator
     Node baseNode(const OutArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
     }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the target in this case) of the
-    // iterator
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the target in this case) of the
+    /// iterator
     Node runningNode(const OutArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
     }
 
-    // \brief Base node of the iterator
-    //
-    // Returns the base node (ie. the target in this case) of the iterator
+    /// \brief Base node of the iterator
+    ///
+    /// Returns the base node (ie. the target in this case) of the iterator
     Node baseNode(const InArcIt &e) const {
       return Parent::target(static_cast<const Arc&>(e));
     }
-    // \brief Running node of the iterator
-    //
-    // Returns the running node (ie. the source in this case) of the
-    // iterator
+    /// \brief Running node of the iterator
+    ///
+    /// Returns the running node (ie. the source in this case) of the
+    /// iterator
     Node runningNode(const InArcIt &e) const {
       return Parent::source(static_cast<const Arc&>(e));
     }
 
-    // Base node of the iterator
-    //
-    // Returns the base node of the iterator
+    /// Base node of the iterator
+    ///
+    /// Returns the base node of the iterator
     Node baseNode(const IncEdgeIt &e) const {
       return e.direction ? u(e) : v(e);
     }
-    // Running node of the iterator
-    //
-    // Returns the running node of the iterator
+    /// Running node of the iterator
+    ///
+    /// Returns the running node of the iterator
     Node runningNode(const IncEdgeIt &e) const {
       return e.direction ? v(e) : u(e);

lemon/circulation.h

@@ -216 +216 @@
     ///@{
 
-    template <typename T>
+    template <typename _FlowMap>
     struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
+      typedef _FlowMap FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
         LEMON_ASSERT(false, "FlowMap is not initialized");
@@ -230 +230 @@
     /// \ref named-templ-param "Named parameter" for setting FlowMap
     /// type.
-    template <typename T>
+    template <typename _FlowMap>
     struct SetFlowMap
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                           SetFlowMapTraits<T> > {
+                           SetFlowMapTraits<_FlowMap> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                          SetFlowMapTraits<T> > Create;
+                          SetFlowMapTraits<_FlowMap> > Create;
     };
 
-    template <typename T>
+    template <typename _Elevator>
     struct SetElevatorTraits : public Traits {
-      typedef T Elevator;
+      typedef _Elevator Elevator;
       static Elevator *createElevator(const Digraph&, int) {
         LEMON_ASSERT(false, "Elevator is not initialized");
@@ -256 +256 @@
     /// \ref run() or \ref init().
     /// \sa SetStandardElevator
-    template <typename T>
+    template <typename _Elevator>
     struct SetElevator
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                           SetElevatorTraits<T> > {
+                           SetElevatorTraits<_Elevator> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                          SetElevatorTraits<T> > Create;
+                          SetElevatorTraits<_Elevator> > Create;
     };
 
-    template <typename T>
+    template <typename _Elevator>
     struct SetStandardElevatorTraits : public Traits {
-      typedef T Elevator;
+      typedef _Elevator Elevator;
       static Elevator *createElevator(const Digraph& digraph, int max_level) {
         return new Elevator(digraph, max_level);
@@ -284 +284 @@
     /// before calling \ref run() or \ref init().
     /// \sa SetElevator
-    template <typename T>
+    template <typename _Elevator>
     struct SetStandardElevator
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                       SetStandardElevatorTraits<T> > {
+                       SetStandardElevatorTraits<_Elevator> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                      SetStandardElevatorTraits<T> > Create;
+                      SetStandardElevatorTraits<_Elevator> > Create;
     };
 
@@ -683 +683 @@
     ///
     /// \note This function calls \ref barrier() for each node,
-    /// so it runs in O(n) time.
+    /// so it runs in \f$O(n)\f$ time.
     ///
     /// \pre Either \ref run() or \ref init() must be called before

lemon/concepts/graph.h

@@ -602 +602 @@
       /// \brief Opposite node on an arc
       ///
-      /// \return The opposite of the given node on the given edge.
+      /// \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.
+      /// \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
+      /// don't have source and target node. But we use these two 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()
+      /// \sa direction
       Node u(Edge) const { return INVALID; }
 
       /// \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; }
 

lemon/concepts/graph_components.h

@@ -21 +21 @@
 ///\brief The concept of graph components.
 
+
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
 #define LEMON_CONCEPTS_GRAPH_COMPONENTS_H
@@ -44 +45 @@
 
 #ifndef DOXYGEN
-    template <char sel = '0'>
+    template <char _selector = '0'>
 #endif
     class GraphItem {
@@ -296 +297 @@
     /// The most of the base digraphs should conform to this concept.
     /// The id's are unique and immutable.
-    template <typename BAS = BaseDigraphComponent>
-    class IDableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class IDableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -374 +375 @@
     /// most of the base undirected graphs should conform to this
     /// concept.  The id's are unique and immutable.
-    template <typename BAS = BaseGraphComponent>
-    class IDableGraphComponent : public IDableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class IDableGraphComponent : public IDableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Edge Edge;
 
-      using IDableDigraphComponent<Base>::id;
+      using IDableDigraphComponent<_Base>::id;
 
       /// \brief Gives back an unique integer id for the Edge.
@@ -425 +426 @@
     /// Skeleton class for graph NodeIt and ArcIt.
     ///
-    template <typename GR, typename Item>
-    class GraphItemIt : public Item {
+    template <typename _Graph, typename _Item>
+    class GraphItemIt : public _Item {
     public:
       /// \brief Default constructor.
@@ -442 +443 @@
       /// Sets the iterator to the first item of \c the graph.
       ///
-      explicit GraphItemIt(const GR&) {}
+      explicit GraphItemIt(const _Graph&) {}
       /// \brief Invalid constructor \& conversion.
       ///
@@ -479 +480 @@
           ++(++it1);
 
-          Item bi = it1;
+          _Item bi = it1;
           bi = it2;
         }
-        GR& g;
+        _Graph& g;
       };
     };
@@ -489 +490 @@
     ///
     /// \note Because InArcIt and OutArcIt may not inherit from the same
-    /// base class, the \c sel is a additional template parameter (selector).
-    /// For InArcIt you should instantiate it with character 'i' and for
+    /// base class, the _selector is a additional template parameter. For
+    /// InArcIt you should instantiate it with character 'i' and for
     /// OutArcIt with 'o'.
-    template <typename GR,
-              typename Item = typename GR::Arc,
-              typename Base = typename GR::Node,
-              char sel = '0'>
-    class GraphIncIt : public Item {
+    template <typename _Graph,
+              typename _Item = typename _Graph::Arc,
+              typename _Base = typename _Graph::Node,
+              char _selector = '0'>
+    class GraphIncIt : public _Item {
     public:
       /// \brief Default constructor.
@@ -507 +508 @@
       /// Copy constructor.
       ///
-      GraphIncIt(GraphIncIt const& gi) : Item(gi) {}
+      GraphIncIt(GraphIncIt const& gi) : _Item(gi) {}
       /// \brief Sets the iterator to the first arc incoming into or outgoing
       /// from the node.
@@ -514 +515 @@
       /// from the node.
       ///
-      explicit GraphIncIt(const GR&, const Base&) {}
+      explicit GraphIncIt(const _Graph&, const _Base&) {}
       /// \brief Invalid constructor \& conversion.
       ///
@@ -546 +547 @@
       struct Constraints {
         void constraints() {
-          checkConcept<GraphItem<sel>, _GraphIncIt>();
+          checkConcept<GraphItem<_selector>, _GraphIncIt>();
           _GraphIncIt it1(graph, node);
           _GraphIncIt it2;
@@ -553 +554 @@
           ++it2 = it1;
           ++(++it1);
-          Item e = it1;
+          _Item e = it1;
           e = it2;
 
         }
 
-        Item arc;
-        Base node;
-        GR graph;
+        _Item arc;
+        _Base node;
+        _Graph graph;
         _GraphIncIt it;
       };
@@ -571 +572 @@
     /// iterator based iterable interface for the digraph structure.
     /// This concept is part of the Digraph concept.
-    template <typename BAS = BaseDigraphComponent>
-    class IterableDigraphComponent : public BAS {
-
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class IterableDigraphComponent : public _Base {
+
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -756 +757 @@
     /// based iterable interface for the undirected graph structure.
     /// This concept is part of the Graph concept.
-    template <typename BAS = BaseGraphComponent>
-    class IterableGraphComponent : public IterableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class IterableGraphComponent : public IterableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -773 +774 @@
       /// @{
 
-      using IterableDigraphComponent<Base>::first;
-      using IterableDigraphComponent<Base>::next;
+      using IterableDigraphComponent<_Base>::first;
+      using IterableDigraphComponent<_Base>::next;
 
       /// \brief Gives back the first edge in the iterating
@@ -808 +809 @@
       void nextInc(Edge&, bool&) const {}
 
-      using IterableDigraphComponent<Base>::baseNode;
-      using IterableDigraphComponent<Base>::runningNode;
+      using IterableDigraphComponent<_Base>::baseNode;
+      using IterableDigraphComponent<_Base>::runningNode;
 
       /// @}
@@ -875 +876 @@
 
         const _Graph& graph;
+
       };
     };
@@ -886 +888 @@
     /// alteration occured in the digraph all the observers will
     /// notified about it.
-    template <typename BAS = BaseDigraphComponent>
-    class AlterableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class AlterableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -944 +946 @@
     /// alteration occured in the graph all the observers will
     /// notified about it.
-    template <typename BAS = BaseGraphComponent>
-    class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class AlterableGraphComponent : public AlterableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Edge Edge;
 
@@ -973 +975 @@
 
         const _Graph& graph;
-      };
+
+      };
+
     };
 
@@ -981 +985 @@
     /// (NodeMap, ArcMap), that is maps that can be used to
     /// associate data to graph descriptors (nodes or arcs).
-    template <typename GR, typename K, typename V>
-    class GraphMap : public ReadWriteMap<K, V> {
-    public:
-
-      typedef ReadWriteMap<K, V> Parent;
+    template <typename _Graph, typename _Item, typename _Value>
+    class GraphMap : public ReadWriteMap<_Item, _Value> {
+    public:
+
+      typedef ReadWriteMap<_Item, _Value> Parent;
 
       /// The graph type of the map.
-      typedef GR Graph;
+      typedef _Graph Graph;
       /// The key type of the map.
-      typedef K Key;
+      typedef _Item Key;
       /// The value type of the map.
-      typedef V Value;
+      typedef _Value Value;
 
       /// \brief Construct a new map.
@@ -1052 +1056 @@
     /// map interface for the digraph structure.
     /// This concept is part of the Digraph concept.
-    template <typename BAS = BaseDigraphComponent>
-    class MappableDigraphComponent : public BAS  {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class MappableDigraphComponent : public _Base  {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -1066 +1070 @@
       /// ReadWrite map of the nodes.
       ///
-      template <typename V>
-      class NodeMap : public GraphMap<Digraph, Node, V> {
+      template <typename _Value>
+      class NodeMap : public GraphMap<Digraph, Node, _Value> {
       public:
-        typedef GraphMap<MappableDigraphComponent, Node, V> Parent;
+        typedef GraphMap<MappableDigraphComponent, Node, _Value> Parent;
 
         /// \brief Construct a new map.
@@ -1080 +1084 @@
         ///
         /// Construct a new map for the digraph and initalise the values.
-        NodeMap(const MappableDigraphComponent& digraph, const V& value)
+        NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
           : Parent(digraph, value) {}
 
@@ -1094 +1098 @@
         template <typename CMap>
         NodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, V>, CMap>();
+          checkConcept<ReadMap<Node, _Value>, CMap>();
           return *this;
         }
@@ -1104 +1108 @@
       /// ReadWrite map of the arcs.
       ///
-      template <typename V>
-      class ArcMap : public GraphMap<Digraph, Arc, V> {
+      template <typename _Value>
+      class ArcMap : public GraphMap<Digraph, Arc, _Value> {
       public:
-        typedef GraphMap<MappableDigraphComponent, Arc, V> Parent;
+        typedef GraphMap<MappableDigraphComponent, Arc, _Value> Parent;
 
         /// \brief Construct a new map.
@@ -1118 +1122 @@
         ///
         /// Construct a new map for the digraph and initalise the values.
-        ArcMap(const MappableDigraphComponent& digraph, const V& value)
+        ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
           : Parent(digraph, value) {}
 
@@ -1132 +1136 @@
         template <typename CMap>
         ArcMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Arc, V>, CMap>();
+          checkConcept<ReadMap<Arc, _Value>, CMap>();
           return *this;
         }
@@ -1188 +1192 @@
     /// map interface for the graph structure.
     /// This concept is part of the Graph concept.
-    template <typename BAS = BaseGraphComponent>
-    class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class MappableGraphComponent : public MappableDigraphComponent<_Base>  {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Edge Edge;
 
@@ -1201 +1205 @@
       /// ReadWrite map of the edges.
       ///
-      template <typename V>
-      class EdgeMap : public GraphMap<Graph, Edge, V> {
+      template <typename _Value>
+      class EdgeMap : public GraphMap<Graph, Edge, _Value> {
       public:
-        typedef GraphMap<MappableGraphComponent, Edge, V> Parent;
+        typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
 
         /// \brief Construct a new map.
@@ -1215 +1219 @@
         ///
         /// Construct a new map for the graph and initalise the values.
-        EdgeMap(const MappableGraphComponent& graph, const V& value)
+        EdgeMap(const MappableGraphComponent& graph, const _Value& value)
           : Parent(graph, value) {}
 
@@ -1229 +1233 @@
         template <typename CMap>
         EdgeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Edge, V>, CMap>();
+          checkConcept<ReadMap<Edge, _Value>, CMap>();
           return *this;
         }
@@ -1273 +1277 @@
     /// difference between the base and this interface is that the
     /// digraph alterations should handled already on this level.
-    template <typename BAS = BaseDigraphComponent>
-    class ExtendableDigraphComponent : public BAS {
-    public:
-      typedef BAS Base;
-
-      typedef typename Base::Node Node;
-      typedef typename Base::Arc Arc;
+    template <typename _Base = BaseDigraphComponent>
+    class ExtendableDigraphComponent : public _Base {
+    public:
+      typedef _Base Base;
+
+      typedef typename _Base::Node Node;
+      typedef typename _Base::Arc Arc;
 
       /// \brief Adds a new node to the digraph.
@@ -1318 +1322 @@
     /// that the graph alterations should handled already on this
     /// level.
-    template <typename BAS = BaseGraphComponent>
-    class ExtendableGraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
-      typedef typename Base::Node Node;
-      typedef typename Base::Edge Edge;
+    template <typename _Base = BaseGraphComponent>
+    class ExtendableGraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
+      typedef typename _Base::Node Node;
+      typedef typename _Base::Edge Edge;
 
       /// \brief Adds a new node to the graph.
@@ -1362 +1366 @@
     /// the base and this interface is that the digraph alterations
     /// should handled already on this level.
-    template <typename BAS = BaseDigraphComponent>
-    class ErasableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class ErasableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -1402 +1406 @@
     /// main difference between the base and this interface is that
     /// the graph alterations should handled already on this level.
-    template <typename BAS = BaseGraphComponent>
-    class ErasableGraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class ErasableGraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
       typedef typename Base::Node Node;
       typedef typename Base::Edge Edge;
@@ -1442 +1446 @@
     /// the base and this interface is that the digraph alterations
     /// should handled already on this level.
-    template <typename BAS = BaseDigraphComponent>
-    class ClearableDigraphComponent : public BAS {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseDigraphComponent>
+    class ClearableDigraphComponent : public _Base {
+    public:
+
+      typedef _Base Base;
 
       /// \brief Erase all nodes and arcs from the digraph.
@@ -1471 +1475 @@
     /// main difference between the base and this interface is that
     /// the graph alterations should handled already on this level.
-    template <typename BAS = BaseGraphComponent>
-    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
-    public:
-
-      typedef BAS Base;
+    template <typename _Base = BaseGraphComponent>
+    class ClearableGraphComponent : public ClearableDigraphComponent<_Base> {
+    public:
+
+      typedef _Base Base;
 
       template <typename _Graph>

lemon/concepts/heap.h

@@ -36 +36 @@
     /// \brief The heap concept.
     ///
-    /// 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.
-    ///
-    /// \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>.
-#ifdef DOXYGEN
-    template <typename PR, typename IM, typename Comp = std::less<PR> >
-#else
-    template <typename PR, typename IM>
-#endif
+    /// Concept class describing the main interface of heaps.
+    template <typename Priority, typename ItemIntMap>
     class Heap {
     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 priorities.
+      typedef Priority Prio;
 
       /// \brief Type to represent the states of the items.
@@ -69 +54 @@
       /// the user.
       ///
-      /// The item-int map must be initialized in such way that it assigns
-      /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+      /// The \c ItemIntMap must be initialized in such a way, that it
+      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
       enum State {
-        IN_HEAP = 0,    ///< The "in heap" state constant.
-        PRE_HEAP = -1,  ///< The "pre heap" state constant.
-        POST_HEAP = -2  ///< The "post heap" state constant.
+        IN_HEAP = 0,
+        PRE_HEAP = -1,
+        POST_HEAP = -2
       };
 
@@ -135 +120 @@
       ///
       /// Returns the priority of the given item.
-      /// \param i The item.
       /// \pre \c i must be in the heap.
+      /// \param i The item.
       Prio operator[](const Item &i) const {}
 
@@ -153 +138 @@
       ///
       /// Decreases the priority of an item to the given value.
+      /// \pre \c i must be stored in the heap with priority at least \c p.
       /// \param i The item.
       /// \param p The priority.
-      /// \pre \c i must be stored in the heap with priority at least \c p.
       void decrease(const Item &i, const Prio &p) {}
 
@@ -161 +146 @@
       ///
       /// Increases the priority of an item to the given value.
+      /// \pre \c i must be stored in the heap with priority at most \c p.
       /// \param i The item.
       /// \param p The priority.
-      /// \pre \c i must be stored in the heap with priority at most \c p.
       void increase(const Item &i, const Prio &p) {}
 

lemon/concepts/path.h

@@ -39 +39 @@
     /// A skeleton structure for representing directed paths in a
     /// digraph.
-    /// \tparam GR The digraph type in which the path is.
+    /// \tparam _Digraph The digraph type in which the path is.
     ///
     /// In a sense, the path can be treated as a list of arcs. The
@@ -46 +46 @@
     /// paths cannot store the source.
     ///
-    template <typename GR>
+    template <typename _Digraph>
     class Path {
     public:
 
       /// Type of the underlying digraph.
-      typedef GR Digraph;
+      typedef _Digraph Digraph;
       /// Arc type of the underlying digraph.
       typedef typename Digraph::Arc Arc;
@@ -206 +206 @@
     /// 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.
+
+    /// \tparam _Digraph  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>
+    ///
+    template <typename _Digraph>
     class PathDumper {
     public:
 
       /// Type of the underlying digraph.
-      typedef GR Digraph;
+      typedef _Digraph Digraph;
       /// Arc type of the underlying digraph.
       typedef typename Digraph::Arc Arc;

lemon/connectivity.h

@@ -47 +47 @@
   /// 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.
+  /// \return %True when there is path between any two nodes in the graph.
   /// \note By definition, the empty graph is connected.
   template <typename Graph>
@@ -235 +235 @@
   /// graph is strongly connected when any two nodes of the graph are
   /// connected with directed paths in both direction.
-  /// \return \c false when the graph is not strongly connected.
+  /// \return %False when the graph is not strongly connected.
   /// \see connected
   ///
@@ -710 +710 @@
   ///
   /// \param graph The graph.
-  /// \return \c true when the graph bi-node-connected.
+  /// \return %True when the graph bi-node-connected.
   template <typename Graph>
   bool biNodeConnected(const Graph& graph) {
@@ -1231 +1231 @@
   /// of the map will be set exactly once, the values will be set descending
   /// order.
-  /// \return \c false when the graph is not DAG.
+  /// \return %False when the graph is not DAG.
   ///
   /// \see topologicalSort
@@ -1280 +1280 @@
   /// 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.
+  /// \return %False when the graph is not DAG.
   /// \see acyclic
   template <typename Digraph>
@@ -1322 +1322 @@
   /// Check that the given undirected graph acyclic.
   /// \param graph The undirected graph.
-  /// \return \c true when there is no circle in the graph.
+  /// \return %True when there is no circle in the graph.
   /// \see dag
   template <typename Graph>
@@ -1356 +1356 @@
   /// Check that the given undirected graph is tree.
   /// \param graph The undirected graph.
-  /// \return \c true when the graph is acyclic and connected.
+  /// \return %True when the graph is acyclic and connected.
   template <typename Graph>
   bool tree(const Graph& graph) {
@@ -1449 +1449 @@
   /// 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.
+  /// \return %True if \c graph is bipartite, %false otherwise.
   /// \sa bipartitePartitions
   template<typename Graph>
@@ -1490 +1490 @@
   /// \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.
+  /// \return %True if \c graph is bipartite, %false otherwise.
   template<typename Graph, typename NodeMap>
   inline bool bipartitePartitions(const Graph &graph, NodeMap &partMap){

lemon/core.h

@@ -1035 +1035 @@
   ///\sa findArc()
   ///\sa ArcLookUp, AllArcLookUp, DynArcLookUp
-  template <typename GR>
-  class ConArcIt : public GR::Arc {
+  template <typename _Graph>
+  class ConArcIt : public _Graph::Arc {
   public:
 
-    typedef GR Graph;
+    typedef _Graph Graph;
     typedef typename Graph::Arc Parent;
 
@@ -1158 +1158 @@
   ///
   ///\sa findEdge()
-  template <typename GR>
-  class ConEdgeIt : public GR::Edge {
+  template <typename _Graph>
+  class ConEdgeIt : public _Graph::Edge {
   public:
 
-    typedef GR Graph;
+    typedef _Graph Graph;
     typedef typename Graph::Edge Parent;
 
@@ -1212 +1212 @@
   ///queries.
   ///
-  ///\tparam GR The type of the underlying digraph.
+  ///\tparam G The type of the underlying digraph.
   ///
   ///\sa ArcLookUp
   ///\sa AllArcLookUp
-  template <typename GR>
+  template<class G>
   class DynArcLookUp
-    : protected ItemSetTraits<GR, typename GR::Arc>::ItemNotifier::ObserverBase
+    : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
   {
   public:
-    typedef typename ItemSetTraits<GR, typename GR::Arc>
+    typedef typename ItemSetTraits<G, typename G::Arc>
     ::ItemNotifier::ObserverBase Parent;
 
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-    typedef GR Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(G);
+    typedef G Digraph;
 
   protected:
 
-    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
+    class AutoNodeMap : public ItemSetTraits<G, Node>::template Map<Arc>::Type {
     public:
 
-      typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
-
-      AutoNodeMap(const GR& digraph) : Parent(digraph, INVALID) {}
+      typedef typename ItemSetTraits<G, Node>::template Map<Arc>::Type Parent;
+
+      AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
 
       virtual void add(const Node& node) {
@@ -1624 +1624 @@
   ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
   ///
-  ///\tparam GR The type of the underlying digraph.
+  ///\tparam G The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa AllArcLookUp
-  template<class GR>
+  template<class G>
   class ArcLookUp
   {
   public:
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-    typedef GR Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(G);
+    typedef G Digraph;
 
   protected:
@@ -1734 +1734 @@
   ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
   ///
-  ///\tparam GR The type of the underlying digraph.
+  ///\tparam G The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa ArcLookUp
-  template<class GR>
-  class AllArcLookUp : public ArcLookUp<GR>
+  template<class G>
+  class AllArcLookUp : public ArcLookUp<G>
   {
-    using ArcLookUp<GR>::_g;
-    using ArcLookUp<GR>::_right;
-    using ArcLookUp<GR>::_left;
-    using ArcLookUp<GR>::_head;
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-    typedef GR Digraph;
+    using ArcLookUp<G>::_g;
+    using ArcLookUp<G>::_right;
+    using ArcLookUp<G>::_left;
+    using ArcLookUp<G>::_head;
+
+    TEMPLATE_DIGRAPH_TYPEDEFS(G);
+    typedef G Digraph;
 
     typename Digraph::template ArcMap<Arc> _next;
@@ -1774 +1774 @@
     ///It builds up the search database, which remains valid until the digraph
     ///changes.
-    AllArcLookUp(const Digraph &g) : ArcLookUp<GR>(g), _next(g) {refreshNext();}
+    AllArcLookUp(const Digraph &g) : ArcLookUp<G>(g), _next(g) {refreshNext();}
 
     ///Refresh the data structure at a node.
@@ -1784 +1784 @@
     void refresh(Node n)
     {
-      ArcLookUp<GR>::refresh(n);
+      ArcLookUp<G>::refresh(n);
       refreshNext(_head[n]);
     }
@@ -1831 +1831 @@
     Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
 #else
-    using ArcLookUp<GR>::operator() ;
+    using ArcLookUp<G>::operator() ;
     Arc operator()(Node s, Node t, Arc prev) const
     {

lemon/dijkstra.h

@@ -39 +39 @@
   /// This operation traits class defines all computational operations and
   /// constants which are used in the Dijkstra algorithm.
-  template <typename V>
+  template <typename Value>
   struct DijkstraDefaultOperationTraits {
-    /// \e
-    typedef V Value;
     /// \brief Gives back the zero value of the type.
     static Value zero() {
@@ -61 +59 @@
   ///Default traits class of Dijkstra class.
   ///\tparam GR The type of the digraph.
-  ///\tparam LEN The type of the length map.
-  template<typename GR, typename LEN>
+  ///\tparam LM The type of the length map.
+  template<class GR, class LM>
   struct DijkstraDefaultTraits
   {
@@ -72 +70 @@
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LEN LengthMap;
+    typedef LM LengthMap;
     ///The type of the length of the arcs.
-    typedef typename LEN::Value Value;
+    typedef typename LM::Value Value;
 
     /// Operation traits for %Dijkstra algorithm.
@@ -103 +101 @@
     ///\sa BinHeap
     ///\sa Dijkstra
-    typedef BinHeap<typename LEN::Value, HeapCrossRef, std::less<Value> > Heap;
+    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
     ///Instantiates a \c Heap.
 
@@ -153 +151 @@
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a \c DistMap.
 
@@ -183 +181 @@
   ///\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
+  ///\tparam LM A \ref concepts::ReadMap "readable" arc map that specifies
   ///the lengths of the arcs.
   ///It is read once for each arc, so the map may involve in
@@ -190 +188 @@
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
 #ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
+  template <typename GR, typename LM, typename TR>
 #else
   template <typename GR=ListDigraph,
-            typename LEN=typename GR::template ArcMap<int>,
-            typename TR=DijkstraDefaultTraits<GR,LEN> >
+            typename LM=typename GR::template ArcMap<int>,
+            typename TR=DijkstraDefaultTraits<GR,LM> >
 #endif
   class Dijkstra {
@@ -916 +914 @@
   ///Default traits class of dijkstra() function.
   ///\tparam GR The type of the digraph.
-  ///\tparam LEN The type of the length map.
-  template<class GR, class LEN>
+  ///\tparam LM The type of the length map.
+  template<class GR, class LM>
   struct DijkstraWizardDefaultTraits
   {
@@ -926 +924 @@
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LEN LengthMap;
+    typedef LM LengthMap;
     ///The type of the length of the arcs.
-    typedef typename LEN::Value Value;
+    typedef typename LM::Value Value;
 
     /// Operation traits for Dijkstra algorithm.
@@ -1010 +1008 @@
     ///The type of the map that stores the distances of the nodes.
     ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a DistMap.
 
@@ -1036 +1034 @@
   /// 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>
+  template<class GR,class LM>
+  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
   {
-    typedef DijkstraWizardDefaultTraits<GR,LEN> Base;
+    typedef DijkstraWizardDefaultTraits<GR,LM> Base;
   protected:
     //The type of the nodes in the digraph.
@@ -1073 +1071 @@
     /// \param g The digraph the algorithm runs on.
     /// \param l The length map.
-    DijkstraWizardBase(const GR &g,const LEN &l) :
+    DijkstraWizardBase(const GR &g,const LM &l) :
       _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
-      _length(reinterpret_cast<void*>(const_cast<LEN*>(&l))),
+      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
       _processed(0), _pred(0), _dist(0), _path(0), _di(0) {}
 
@@ -1284 +1282 @@
   ///\sa DijkstraWizard
   ///\sa Dijkstra
-  template<typename GR, typename LEN>
-  DijkstraWizard<DijkstraWizardBase<GR,LEN> >
-  dijkstra(const GR &digraph, const LEN &length)
+  template<class GR, class LM>
+  DijkstraWizard<DijkstraWizardBase<GR,LM> >
+  dijkstra(const GR &digraph, const LM &length)
   {
-    return DijkstraWizard<DijkstraWizardBase<GR,LEN> >(digraph,length);
+    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(digraph,length);
   }
 

lemon/edge_set.h

@@ -256 +256 @@
   /// concept.
   ///
-  /// This class fully conforms to the \ref concepts::Digraph
+  /// This class is fully conform to the \ref concepts::Digraph
   /// "Digraph" concept.
   template <typename GR>
@@ -337 +337 @@
     /// Add a new arc to the digraph with source node \c s
     /// and target node \c t.
-    /// \return The new arc.
+    /// \return the new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
@@ -685 +685 @@
   /// concept.
   ///
-  /// This class fully conforms to the \ref concepts::Graph "Graph"
+  /// This class is fully conform to the \ref concepts::Graph "Graph"
   /// concept.
   template <typename GR>
@@ -762 +762 @@
     /// Add a new edge to the graph with node \c u
     /// and node \c v endpoints.
-    /// \return The new edge.
+    /// \return the new edge.
     Edge addEdge(const Node& u, const Node& v) {
       return Parent::addEdge(u, v);
@@ -953 +953 @@
   /// validity can be checked with the \c valid() member function.
   ///
-  /// This class fully conforms to the \ref concepts::Digraph
+  /// This class is fully conform to the \ref concepts::Digraph
   /// "Digraph" concept.
   template <typename GR>
@@ -1042 +1042 @@
     /// Add a new arc to the digraph with source node \c s
     /// and target node \c t.
-    /// \return The new arc.
+    /// \return the new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
@@ -1301 +1301 @@
   /// be checked with the \c valid() member function.
   ///
-  /// This class fully conforms to the \ref concepts::Graph
+  /// This class is fully conform to the \ref concepts::Graph
   /// "Graph" concept.
   template <typename GR>
@@ -1390 +1390 @@
     /// Add a new edge to the graph with node \c u
     /// and node \c v endpoints.
-    /// \return The new edge.
+    /// \return the new edge.
     Edge addEdge(const Node& u, const Node& v) {
       return Parent::addEdge(u, v);

lemon/elevator.h

@@ -47 +47 @@
   ///\sa LinkedElevator
   ///
-  ///\param GR Type of the underlying graph.
-  ///\param Item Type of the items the data is assigned to (\c GR::Node,
-  ///\c GR::Arc or \c GR::Edge).
-  template<class GR, class Item>
+  ///\param Graph Type of the underlying graph.
+  ///\param Item Type of the items the data is assigned to (Graph::Node,
+  ///Graph::Arc, Graph::Edge).
+  template<class Graph, class Item>
   class Elevator
   {
@@ -61 +61 @@
 
     typedef Item *Vit;
-    typedef typename ItemSetTraits<GR,Item>::template Map<Vit>::Type VitMap;
-    typedef typename ItemSetTraits<GR,Item>::template Map<int>::Type IntMap;
-
-    const GR &_g;
+    typedef typename ItemSetTraits<Graph,Item>::template Map<Vit>::Type VitMap;
+    typedef typename ItemSetTraits<Graph,Item>::template Map<int>::Type IntMap;
+
+    const Graph &_g;
     int _max_level;
     int _item_num;
@@ -106 +106 @@
     ///\param max_level The maximum allowed level.
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>.
-    Elevator(const GR &graph,int max_level) :
+    Elevator(const Graph &graph,int max_level) :
       _g(graph),
       _max_level(max_level),
@@ -123 +123 @@
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>,
     ///where \c max_level is equal to the number of labeled items in the graph.
-    Elevator(const GR &graph) :
+    Elevator(const Graph &graph) :
       _g(graph),
-      _max_level(countItems<GR, Item>(graph)),
+      _max_level(countItems<Graph, Item>(graph)),
       _item_num(_max_level),
       _where(graph),
@@ -431 +431 @@
       _last_active[0]=&_items[0]-1;
       Vit n=&_items[0];
-      for(typename ItemSetTraits<GR,Item>::ItemIt i(_g);i!=INVALID;++i)
+      for(typename ItemSetTraits<Graph,Item>::ItemIt i(_g);i!=INVALID;++i)
         {
           *n=i;
@@ -490 +490 @@
   ///\sa Elevator
   ///
-  ///\param GR Type of the underlying graph.
-  ///\param Item Type of the items the data is assigned to (\c GR::Node,
-  ///\c GR::Arc or \c GR::Edge).
-  template <class GR, class Item>
+  ///\param Graph Type of the underlying graph.
+  ///\param Item Type of the items the data is assigned to (Graph::Node,
+  ///Graph::Arc, Graph::Edge).
+  template <class Graph, class Item>
   class LinkedElevator {
   public:
@@ -502 +502 @@
   private:
 
-    typedef typename ItemSetTraits<GR,Item>::
+    typedef typename ItemSetTraits<Graph,Item>::
     template Map<Item>::Type ItemMap;
-    typedef typename ItemSetTraits<GR,Item>::
+    typedef typename ItemSetTraits<Graph,Item>::
     template Map<int>::Type IntMap;
-    typedef typename ItemSetTraits<GR,Item>::
+    typedef typename ItemSetTraits<Graph,Item>::
     template Map<bool>::Type BoolMap;
 
-    const GR &_graph;
+    const Graph &_graph;
     int _max_level;
     int _item_num;
@@ -526 +526 @@
     ///\param max_level The maximum allowed level.
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>.
-    LinkedElevator(const GR& graph, int max_level)
+    LinkedElevator(const Graph& graph, int max_level)
       : _graph(graph), _max_level(max_level), _item_num(_max_level),
         _first(_max_level + 1), _last(_max_level + 1),
@@ -539 +539 @@
     ///Set the range of the possible labels to <tt>[0..max_level]</tt>,
     ///where \c max_level is equal to the number of labeled items in the graph.
-    LinkedElevator(const GR& graph)
-      : _graph(graph), _max_level(countItems<GR, Item>(graph)),
+    LinkedElevator(const Graph& graph)
+      : _graph(graph), _max_level(countItems<Graph, Item>(graph)),
         _item_num(_max_level),
         _first(_max_level + 1), _last(_max_level + 1),
@@ -936 +936 @@
       }
       _init_level = 0;
-      for(typename ItemSetTraits<GR,Item>::ItemIt i(_graph);
+      for(typename ItemSetTraits<Graph,Item>::ItemIt i(_graph);
           i != INVALID; ++i) {
         _level.set(i, _max_level);

lemon/euler.h

@@ -55 +55 @@
   ///If \c g is not Euler then the resulted tour will not be full or closed.
   ///\sa EulerIt
-  template<typename GR>
+  template<class Digraph>
   class DiEulerIt
   {
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-    typedef typename GR::Arc Arc;
-    typedef typename GR::ArcIt ArcIt;
-    typedef typename GR::OutArcIt OutArcIt;
-    typedef typename GR::InArcIt InArcIt;
-
-    const GR &g;
-    typename GR::template NodeMap<OutArcIt> nedge;
+    typedef typename Digraph::Node Node;
+    typedef typename Digraph::NodeIt NodeIt;
+    typedef typename Digraph::Arc Arc;
+    typedef typename Digraph::ArcIt ArcIt;
+    typedef typename Digraph::OutArcIt OutArcIt;
+    typedef typename Digraph::InArcIt InArcIt;
+
+    const Digraph &g;
+    typename Digraph::template NodeMap<OutArcIt> nedge;
     std::list<Arc> euler;
 
@@ -73 +73 @@
     ///Constructor
 
-    ///\param gr A digraph.
+    ///\param _g A digraph.
     ///\param start The starting point of the tour. If it is not given
     ///       the tour will start from the first node.
-    DiEulerIt(const GR &gr, typename GR::Node start = INVALID)
-      : g(gr), nedge(g)
+    DiEulerIt(const Digraph &_g,typename Digraph::Node start=INVALID)
+      : g(_g), nedge(g)
     {
       if(start==INVALID) start=NodeIt(g);
@@ -146 +146 @@
   ///If \c g is not Euler then the resulted tour will not be full or closed.
   ///\sa EulerIt
-  template<typename GR>
+  template<class Digraph>
   class EulerIt
   {
-    typedef typename GR::Node Node;
-    typedef typename GR::NodeIt NodeIt;
-    typedef typename GR::Arc Arc;
-    typedef typename GR::Edge Edge;
-    typedef typename GR::ArcIt ArcIt;
-    typedef typename GR::OutArcIt OutArcIt;
-    typedef typename GR::InArcIt InArcIt;
-
-    const GR &g;
-    typename GR::template NodeMap<OutArcIt> nedge;
-    typename GR::template EdgeMap<bool> visited;
+    typedef typename Digraph::Node Node;
+    typedef typename Digraph::NodeIt NodeIt;
+    typedef typename Digraph::Arc Arc;
+    typedef typename Digraph::Edge Edge;
+    typedef typename Digraph::ArcIt ArcIt;
+    typedef typename Digraph::OutArcIt OutArcIt;
+    typedef typename Digraph::InArcIt InArcIt;
+
+    const Digraph &g;
+    typename Digraph::template NodeMap<OutArcIt> nedge;
+    typename Digraph::template EdgeMap<bool> visited;
     std::list<Arc> euler;
 
@@ -166 +166 @@
     ///Constructor
 
-    ///\param gr An graph.
+    ///\param _g An graph.
     ///\param start The starting point of the tour. If it is not given
     ///       the tour will start from the first node.
-    EulerIt(const GR &gr, typename GR::Node start = INVALID)
-      : g(gr), nedge(g), visited(g, false)
+    EulerIt(const Digraph &_g,typename Digraph::Node start=INVALID)
+      : g(_g), nedge(g), visited(g,false)
     {
       if(start==INVALID) start=NodeIt(g);
@@ -239 +239 @@
   ///for each node. <em>Therefore, there are digraphs which are not Eulerian,
   ///but still have an Euler tour</em>.
-  template<typename GR>
+  template<class Digraph>
 #ifdef DOXYGEN
   bool
 #else
-  typename enable_if<UndirectedTagIndicator<GR>,bool>::type
-  eulerian(const GR &g)
-  {
-    for(typename GR::NodeIt n(g);n!=INVALID;++n)
+  typename enable_if<UndirectedTagIndicator<Digraph>,bool>::type
+  eulerian(const Digraph &g)
+  {
+    for(typename Digraph::NodeIt n(g);n!=INVALID;++n)
       if(countIncEdges(g,n)%2) return false;
     return connected(g);
   }
-  template<class GR>
-  typename disable_if<UndirectedTagIndicator<GR>,bool>::type
+  template<class Digraph>
+  typename disable_if<UndirectedTagIndicator<Digraph>,bool>::type
 #endif
-  eulerian(const GR &g)
-  {
-    for(typename GR::NodeIt n(g);n!=INVALID;++n)
+  eulerian(const Digraph &g)
+  {
+    for(typename Digraph::NodeIt n(g);n!=INVALID;++n)
       if(countInArcs(g,n)!=countOutArcs(g,n)) return false;
-    return connected(Undirector<const GR>(g));
+    return connected(Undirector<const Digraph>(g));
   }
 

lemon/graph_to_eps.h

@@ -65 +65 @@
 ///Default traits class of \ref GraphToEps.
 ///
-///\param GR is the type of the underlying graph.
-template<class GR>
+///\c G is the type of the underlying graph.
+template<class G>
 struct DefaultGraphToEpsTraits
 {
-  typedef GR Graph;
+  typedef G Graph;
   typedef typename Graph::Node Node;
   typedef typename Graph::NodeIt NodeIt;
@@ -140 +140 @@
 
   ///Constructor
-  ///\param gr  Reference to the graph to be printed.
-  ///\param ost Reference to the output stream.
+  ///\param _g  Reference to the graph to be printed.
+  ///\param _os Reference to the output stream.
+  ///\param _os Reference to the output stream.
   ///By default it is <tt>std::cout</tt>.
-  ///\param pros If it is \c true, then the \c ostream referenced by \c os
+  ///\param _pros If it is \c true, then the \c ostream referenced by \c _os
   ///will be explicitly deallocated by the destructor.
-  DefaultGraphToEpsTraits(const GR &gr, std::ostream& ost = std::cout,
-                          bool pros = false) :
-    g(gr), os(ost),
+  DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout,
+                          bool _pros=false) :
+    g(_g), os(_os),
     _coords(dim2::Point<double>(1,1)), _nodeSizes(1), _nodeShapes(0),
     _nodeColors(WHITE), _arcColors(BLACK),
@@ -158 +159 @@
     _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
     _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
-    _undirected(lemon::UndirectedTagIndicator<GR>::value),
-    _pleaseRemoveOsStream(pros), _scaleToA4(false),
+    _undirected(lemon::UndirectedTagIndicator<G>::value),
+    _pleaseRemoveOsStream(_pros), _scaleToA4(false),
     _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK),
     _autoNodeScale(false),
@@ -1134 +1135 @@
 ///to the end of the parameter list.
 ///\sa GraphToEps
-///\sa graphToEps(GR &g, const char *file_name)
-template<class GR>
-GraphToEps<DefaultGraphToEpsTraits<GR> >
-graphToEps(GR &g, std::ostream& os=std::cout)
+///\sa graphToEps(G &g, const char *file_name)
+template<class G>
+GraphToEps<DefaultGraphToEpsTraits<G> >
+graphToEps(G &g, std::ostream& os=std::cout)
 {
   return
-    GraphToEps<DefaultGraphToEpsTraits<GR> >(DefaultGraphToEpsTraits<GR>(g,os));
+    GraphToEps<DefaultGraphToEpsTraits<G> >(DefaultGraphToEpsTraits<G>(g,os));
 }
 
@@ -1147 +1148 @@
 ///\ingroup eps_io
 ///This function does the same as
-///\ref graphToEps(GR &g,std::ostream& os)
+///\ref graphToEps(G &g,std::ostream& os)
 ///but it writes its output into the file \c file_name
 ///instead of a stream.
-///\sa graphToEps(GR &g, std::ostream& os)
-template<class GR>
-GraphToEps<DefaultGraphToEpsTraits<GR> >
-graphToEps(GR &g,const char *file_name)
+///\sa graphToEps(G &g, std::ostream& os)
+template<class G>
+GraphToEps<DefaultGraphToEpsTraits<G> >
+graphToEps(G &g,const char *file_name)
 {
   std::ostream* os = new std::ofstream(file_name);
@@ -1160 +1161 @@
     throw IoError("Cannot write file", file_name);
   }
-  return GraphToEps<DefaultGraphToEpsTraits<GR> >
-    (DefaultGraphToEpsTraits<GR>(g,*os,true));
+  return GraphToEps<DefaultGraphToEpsTraits<G> >
+    (DefaultGraphToEpsTraits<G>(g,*os,true));
 }
 
@@ -1168 +1169 @@
 ///\ingroup eps_io
 ///This function does the same as
-///\ref graphToEps(GR &g,std::ostream& os)
+///\ref graphToEps(G &g,std::ostream& os)
 ///but it writes its output into the file \c file_name
 ///instead of a stream.
-///\sa graphToEps(GR &g, std::ostream& os)
-template<class GR>
-GraphToEps<DefaultGraphToEpsTraits<GR> >
-graphToEps(GR &g,const std::string& file_name)
+///\sa graphToEps(G &g, std::ostream& os)
+template<class G>
+GraphToEps<DefaultGraphToEpsTraits<G> >
+graphToEps(G &g,const std::string& file_name)
 {
   std::ostream* os = new std::ofstream(file_name.c_str());
@@ -1181 +1182 @@
     throw IoError("Cannot write file", file_name);
   }
-  return GraphToEps<DefaultGraphToEpsTraits<GR> >
-    (DefaultGraphToEpsTraits<GR>(g,*os,true));
+  return GraphToEps<DefaultGraphToEpsTraits<G> >
+    (DefaultGraphToEpsTraits<G>(g,*os,true));
 }
 

lemon/grid_graph.h

@@ -497 +497 @@
   ///\endcode
   ///
-  /// This graph type fully conforms to the \ref concepts::Graph
+  /// This graph type is fully conform to the \ref concepts::Graph
   /// "Graph" concept, and it also has an important extra feature
   /// that its maps are real \ref concepts::ReferenceMap

lemon/hao_orlin.h

@@ -58 +58 @@
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki
   /// which solves the undirected problem in
-  /// \f$ O(nm + n^2 \log n) \f$ time: it is implemented in the
+  /// \f$ O(nm + n^2 \log(n)) \f$ time: it is implemented in the
   /// NagamochiIbaraki algorithm class.
   ///
-  /// \param GR The digraph class the algorithm runs on.
-  /// \param CAP An arc map of capacities which can be any numreric type.
-  /// The default type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \param TOL Tolerance class for handling inexact computations. The
-  /// default tolerance type is \ref Tolerance "Tolerance<CAP::Value>".
+  /// \param _Digraph is the graph type of the algorithm.
+  /// \param _CapacityMap is an edge map of capacities which should
+  /// be any numreric type. The default type is _Digraph::ArcMap<int>.
+  /// \param _Tolerance is the handler of the inexact computation. The
+  /// default type for this is Tolerance<CapacityMap::Value>.
 #ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TOL>
+  template <typename _Digraph, typename _CapacityMap, typename _Tolerance>
 #else
-  template <typename GR,
-            typename CAP = typename GR::template ArcMap<int>,
-            typename TOL = Tolerance<typename CAP::Value> >
+  template <typename _Digraph,
+            typename _CapacityMap = typename _Digraph::template ArcMap<int>,
+            typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
 #endif
   class HaoOrlin {
   private:
 
-    typedef GR Digraph;
-    typedef CAP CapacityMap;
-    typedef TOL Tolerance;
+    typedef _Digraph Digraph;
+    typedef _CapacityMap CapacityMap;
+    typedef _Tolerance Tolerance;
 
     typedef typename CapacityMap::Value Value;
@@ -818 +818 @@
     /// \name Execution control
     /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \ref run().
+    /// one of the member functions called \c run(...).
     /// \n
     /// If you need more control on the execution,

lemon/hypercube_graph.h

@@ -292 +292 @@
   /// (assuming that the size of \c int is 32 bit).
   ///
-  /// This graph type fully conforms to the \ref concepts::Graph
+  /// This graph type is fully conform to the \ref concepts::Graph
   /// "Graph" concept, and it also has an important extra feature
   /// that its maps are real \ref concepts::ReferenceMap

lemon/lgf_reader.h

@@ -449 +449 @@
   /// a single pass, because the arcs are not constructed when the node
   /// maps are read.
-  template <typename GR>
+  template <typename _Digraph>
   class DigraphReader {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 
   private:
 
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 
     std::istream* _is;
@@ -1247 +1247 @@
   /// arc map.  Similarly, an attribute can be read into an arc, if
   /// it's value is an edge label prefixed with \c '+' or \c '-'.
-  template <typename GR>
+  template <typename _Graph>
   class GraphReader {
   public:
 
-    typedef GR Graph;
+    typedef _Graph Graph;
+    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
   private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
     std::istream* _is;
@@ -1358 +1357 @@
 
   private:
-    template <typename Graph>
-    friend GraphReader<Graph> graphReader(Graph& graph, std::istream& is);
-    template <typename Graph>
-    friend GraphReader<Graph> graphReader(Graph& graph, const std::string& fn); 
-    template <typename Graph>
-    friend GraphReader<Graph> graphReader(Graph& graph, const char *fn);
+    template <typename GR>
+    friend GraphReader<GR> graphReader(GR& graph, std::istream& is);
+    template <typename GR>
+    friend GraphReader<GR> graphReader(GR& graph, const std::string& fn); 
+    template <typename GR>
+    friend GraphReader<GR> graphReader(GR& graph, const char *fn);
 
     GraphReader(GraphReader& other)

lemon/lgf_writer.h

@@ -407 +407 @@
   /// the \c ostream() function, hence the second pass can append its
   /// output to the output of the first pass.
-  template <typename GR>
+  template <typename _Digraph>
   class DigraphWriter {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
 
@@ -975 +975 @@
   /// section as a \c '+' or a \c '-' prefix (depends on the direction
   /// of the arc) and the label of corresponding edge.
-  template <typename GR>
+  template <typename _Graph>
   class GraphWriter {
   public:
 
-    typedef GR Graph;
+    typedef _Graph Graph;
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
@@ -1074 +1074 @@
   private:
 
-    template <typename Graph>
-    friend GraphWriter<Graph> graphWriter(const Graph& graph,
-                                          std::ostream& os);
-    template <typename Graph>
-    friend GraphWriter<Graph> graphWriter(const Graph& graph,
-                                          const std::string& fn);
-    template <typename Graph>
-    friend GraphWriter<Graph> graphWriter(const Graph& graph,
-                                          const char *fn);
+    template <typename GR>
+    friend GraphWriter<GR> graphWriter(const GR& graph,
+                                       std::ostream& os);
+    template <typename GR>
+    friend GraphWriter<GR> graphWriter(const GR& graph,
+                                       const std::string& fn);
+    template <typename GR>
+    friend GraphWriter<GR> graphWriter(const GR& graph,
+                                       const char *fn);
     
     GraphWriter(GraphWriter& other)

lemon/list_graph.h

@@ -352 +352 @@
 
     ///Add a new node to the digraph.
-    ///\return The new node.
+    ///\return the new node.
     Node addNode() { return Parent::addNode(); }
 
@@ -359 +359 @@
     ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
-    ///\return The new arc.
+    ///\return the new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
@@ -1209 +1209 @@
     ///
     /// Add a new node to the graph.
-    /// \return The new node.
+    /// \return the new node.
     Node addNode() { return Parent::addNode(); }
 
@@ -1216 +1216 @@
     /// Add a new edge to the graph with source node \c s
     /// and target node \c t.
-    /// \return The new edge.
+    /// \return the new edge.
     Edge addEdge(const Node& s, const Node& t) {
       return Parent::addEdge(s, t);

lemon/maps.h

@@ -64 +64 @@
   class NullMap : public MapBase<K, V> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back a default constructed element.
@@ -104 +103 @@
     V _value;
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Default constructor
@@ -171 +169 @@
   class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor.
@@ -206 +203 @@
   class IdentityMap : public MapBase<T, T> {
   public:
-    ///\e
-    typedef T Key;
-    ///\e
-    typedef T Value;
+    typedef MapBase<T, T> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back the given value without any modification.
@@ -250 +246 @@
   public:
 
+    typedef MapBase<int, V> Parent;
     /// Key type
-    typedef int Key;
+    typedef typename Parent::Key Key;
     /// Value type
-    typedef V Value;
+    typedef typename Parent::Value Value;
     /// Reference type
     typedef typename Vector::reference Reference;
@@ -357 +354 @@
   /// The simplest way of using this map is through the sparseMap()
   /// function.
-  template <typename K, typename V, typename Comp = std::less<K> >
+  template <typename K, typename V, typename Compare = std::less<K> >
   class SparseMap : public MapBase<K, V> {
     template <typename K1, typename V1, typename C1>
@@ -363 +360 @@
   public:
 
+    typedef MapBase<K, V> Parent;
     /// Key type
-    typedef K Key;
+    typedef typename Parent::Key Key;
     /// Value type
-    typedef V Value;
+    typedef typename Parent::Value Value;
     /// Reference type
     typedef Value& Reference;
@@ -376 +374 @@
   private:
 
-    typedef std::map<K, V, Comp> Map;
+    typedef std::map<K, V, Compare> Map;
     Map _map;
     Value _value;
@@ -492 +490 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M2::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M2::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     ComposeMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
 
-    ///\e
+    /// \e
     typename MapTraits<M1>::ConstReturnValue
     operator[](const Key &k) const { return _m1[_m2[k]]; }
@@ -549 +546 @@
     F _f;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<typename M1::Key, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     CombineMap(const M1 &m1, const M2 &m2, const F &f = F())
       : _m1(m1), _m2(m2), _f(f) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _f(_m1[k],_m2[k]); }
   };
@@ -620 +616 @@
     F _f;
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<K, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     FunctorToMap(const F &f = F()) : _f(f) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _f(k); }
   };
@@ -675 +670 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
-
-    typedef typename M::Key argument_type;
-    typedef typename M::Value result_type;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
+
+    typedef typename Parent::Key argument_type;
+    typedef typename Parent::Value result_type;
 
     /// Constructor
     MapToFunctor(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator()(const Key &k) const { return _m[k]; }
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]; }
   };
@@ -716 +710 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef V Value;
+    typedef MapBase<typename M::Key, V> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -727 +720 @@
     ConvertMap(const M &m) : _m(m) {}
 
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]; }
   };
@@ -759 +752 @@
     M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -806 +798 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     AddMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]+_m2[k]; }
   };
@@ -855 +846 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     SubMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]-_m2[k]; }
   };
@@ -905 +895 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     MulMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]*_m2[k]; }
   };
@@ -954 +943 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef typename M1::Value Value;
+    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     DivMap(const M1 &m1,const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]/_m2[k]; }
   };
@@ -1005 +993 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1016 +1003 @@
     /// \param v The constant value.
     ShiftMap(const M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]+_v; }
   };
@@ -1036 +1023 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1047 +1033 @@
     /// \param v The constant value.
     ShiftWriteMap(M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m[k]+_v; }
-    ///\e
+    /// \e
     void set(const Key &k, const Value &v) { _m.set(k, v-_v); }
   };
@@ -1108 +1094 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1119 +1104 @@
     /// \param v The constant value.
     ScaleMap(const M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _v*_m[k]; }
   };
@@ -1140 +1125 @@
     C _v;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
@@ -1151 +1135 @@
     /// \param v The constant value.
     ScaleWriteMap(M &m, const C &v) : _m(m), _v(v) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _v*_m[k]; }
-    ///\e
+    /// \e
     void set(const Key &k, const Value &v) { _m.set(k, v/_v); }
   };
@@ -1210 +1194 @@
     const M& _m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NegMap(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return -_m[k]; }
   };
@@ -1246 +1229 @@
     M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NegWriteMap(M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return -_m[k]; }
-    ///\e
+    /// \e
     void set(const Key &k, const Value &v) { _m.set(k, -v); }
   };
@@ -1301 +1283 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef typename M::Value Value;
+    typedef MapBase<typename M::Key, typename M::Value> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     AbsMap(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const {
       Value tmp = _m[k];
@@ -1357 +1338 @@
   class TrueMap : public MapBase<K, bool> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<K, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back \c true.
@@ -1395 +1375 @@
   class FalseMap : public MapBase<K, bool> {
   public:
-    ///\e
-    typedef K Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<K, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Gives back \c false.
@@ -1441 +1420 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     AndMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]&&_m2[k]; }
   };
@@ -1490 +1468 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     OrMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]||_m2[k]; }
   };
@@ -1530 +1507 @@
     const M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NotMap(const M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return !_m[k]; }
   };
@@ -1557 +1533 @@
     M &_m;
   public:
-    ///\e
-    typedef typename M::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     NotWriteMap(M &m) : _m(m) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return !_m[k]; }
-    ///\e
+    /// \e
     void set(const Key &k, bool v) { _m.set(k, !v); }
   };
@@ -1621 +1596 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     EqualMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]==_m2[k]; }
   };
@@ -1670 +1644 @@
     const M2 &_m2;
   public:
-    ///\e
-    typedef typename M1::Key Key;
-    ///\e
-    typedef bool Value;
+    typedef MapBase<typename M1::Key, bool> Parent;
+    typedef typename Parent::Key Key;
+    typedef typename Parent::Value Value;
 
     /// Constructor
     LessMap(const M1 &m1, const M2 &m2) : _m1(m1), _m2(m2) {}
-    ///\e
+    /// \e
     Value operator[](const Key &k) const { return _m1[k]<_m2[k]; }
   };
@@ -1733 +1706 @@
   /// function.
   ///
-  /// \tparam IT The type of the iterator.
-  /// \tparam KEY The key type of the map. The default value set
+  /// \tparam It The type of the iterator.
+  /// \tparam Ke The key type of the map. The default value set
   /// according to the iterator type should work in most cases.
   ///
@@ -1740 +1713 @@
   /// for the elements or the iterator should be an inserter iterator.
 #ifdef DOXYGEN
-  template <typename IT, typename KEY>
+  template <typename It, typename Ke>
 #else
-  template <typename IT,
-            typename KEY = typename _maps_bits::IteratorTraits<IT>::Value>
+  template <typename It,
+            typename Ke=typename _maps_bits::IteratorTraits<It>::Value>
 #endif
-  class LoggerBoolMap : public MapBase<KEY, bool> {
-  public:
-
-    ///\e
-    typedef KEY Key;
-    ///\e
+  class LoggerBoolMap {
+  public:
+    typedef It Iterator;
+
+    typedef Ke Key;
     typedef bool Value;
-    ///\e
-    typedef IT Iterator;
 
     /// Constructor
@@ -1816 +1786 @@
   /// @{
 
-  /// \brief Provides an immutable and unique id for each item in a graph.
-  ///
-  /// 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 
-  ///  - \b unique: different items get different ids,
-  ///  - \b immutable: the id of an item does not change (even if you
-  ///    delete other nodes).
-  ///
-  /// Using this map you get access (i.e. can read) the inner id values of
-  /// 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
+  /// Provides an immutable and unique id for each item in the graph.
+
+  /// The IdMap class provides a unique and immutable id for each item of the
+  /// same type (e.g. node) in the graph. This id is <ul><li>\b unique:
+  /// different items (nodes) get different ids <li>\b immutable: the id of an
+  /// item (node) does not change (even if you delete other nodes).  </ul>
+  /// Through this map you get access (i.e. can read) the inner id values of
+  /// the items stored in the graph. This map can be inverted with its member
   /// class \c InverseMap or with the \c operator() member.
   ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see DescriptorMap
-  template <typename GR, typename K>
-  class IdMap : public MapBase<K, int> {
-  public:
-    /// The graph type of IdMap.
-    typedef GR Graph;
-    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
-    typedef K Item;
-    /// The key type of IdMap (\c Node, \c Arc or \c Edge).
-    typedef K Key;
-    /// The value type of IdMap.
+  template <typename _Graph, typename _Item>
+  class IdMap {
+  public:
+    typedef _Graph Graph;
     typedef int Value;
+    typedef _Item Item;
+    typedef _Item Key;
 
     /// \brief Constructor.
@@ -1856 +1814 @@
     int operator[](const Item& item) const { return _graph->id(item);}
 
-    /// \brief Gives back the \e item by its id.
-    ///
-    /// Gives back the \e item by its id.
+    /// \brief Gives back the item by its id.
+    ///
+    /// Gives back the item by its id.
     Item operator()(int id) { return _graph->fromId(id, Item()); }
 
@@ -1866 +1824 @@
   public:
 
-    /// \brief This class represents the inverse of its owner (IdMap).
-    ///
-    /// This class represents the inverse of its owner (IdMap).
+    /// \brief The class represents the inverse of its owner (IdMap).
+    ///
+    /// The class represents the inverse of its owner (IdMap).
     /// \see inverse()
     class InverseMap {
@@ -1886 +1844 @@
       ///
       /// Gives back the given item from its id.
+      ///
       Item operator[](int id) const { return _graph->fromId(id, Item());}
 
@@ -1896 +1855 @@
     /// Gives back the inverse of the IdMap.
     InverseMap inverse() const { return InverseMap(*_graph);}
-  };
-
-
-  /// \brief General invertable graph map type.
-
-  /// This class provides simple invertable graph maps.
-  /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
+
+  };
+
+
+  /// \brief General invertable graph-map type.
+
+  /// This type provides simple invertable graph-maps.
+  /// The InvertableMap wraps an arbitrary ReadWriteMap
   /// and if a key is set to a new value then store it
   /// in the inverse map.
@@ -1909 +1869 @@
   /// with stl compatible forward iterator.
   ///
-  /// \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.
+  /// \tparam _Graph The graph type.
+  /// \tparam _Item The item type of the graph.
+  /// \tparam _Value The value type of the map.
   ///
   /// \see IterableValueMap
-  template <typename GR, typename K, typename V>
+  template <typename _Graph, typename _Item, typename _Value>
   class InvertableMap
-    : protected ItemSetTraits<GR, K>::template Map<V>::Type {
+    : protected ItemSetTraits<_Graph, _Item>::template Map<_Value>::Type {
   private:
 
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<V>::Type Map;
-
-    typedef std::map<V, K> Container;
+    typedef typename ItemSetTraits<_Graph, _Item>::
+    template Map<_Value>::Type Map;
+    typedef _Graph Graph;
+
+    typedef std::map<_Value, _Item> Container;
     Container _inv_map;
 
   public:
 
-    /// The graph type of InvertableMap.
-    typedef GR Graph;
-    /// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
-    typedef K Item;
-    /// The key type of InvertableMap (\c Node, \c Arc or \c Edge).
-    typedef K Key;
-    /// The value type of InvertableMap.
-    typedef V Value;
+    /// The key type of InvertableMap (Node, Arc, Edge).
+    typedef typename Map::Key Key;
+    /// The value type of the InvertableMap.
+    typedef typename Map::Value Value;
 
     /// \brief Constructor.
     ///
-    /// Construct a new InvertableMap for the given graph.
+    /// Construct a new InvertableMap for the graph.
+    ///
     explicit InvertableMap(const Graph& graph) : Map(graph) {}
 
@@ -1946 +1903 @@
     /// 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.
+    /// be accessed in the [beginValue, endValue) range.
+    ///
     class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
@@ -1978 +1936 @@
     /// 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>
+    /// map can be accessed in the [beginValue, endValue)
     /// range.
     ValueIterator beginValue() const {
@@ -1988 +1946 @@
     /// 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>
+    /// map can be accessed in the [beginValue, endValue)
     /// range.
     ValueIterator endValue() const {
@@ -1994 +1952 @@
     }
 
-    /// \brief Sets the value associated with the given key.
-    ///
-    /// Sets the value associated with the given key.
+    /// \brief The setter function of the map.
+    ///
+    /// Sets the mapped value.
     void set(const Key& key, const Value& val) {
       Value oldval = Map::operator[](key);
@@ -2007 +1965 @@
     }
 
-    /// \brief Returns the value associated with the given key.
-    ///
-    /// Returns the value associated with the given key.
+    /// \brief The getter function of the map.
+    ///
+    /// It gives back the value associated with the key.
     typename MapTraits<Map>::ConstReturnValue
     operator[](const Key& key) const {
@@ -2025 +1983 @@
   protected:
 
-    /// \brief Erase the key from the map and the inverse map.
-    ///
-    /// Erase the key from the map and the inverse map. It is called by the
+    /// \brief Erase the key from the map.
+    ///
+    /// Erase the key to the map. It is called by the
     /// \c AlterationNotifier.
     virtual void erase(const Key& key) {
@@ -2038 +1996 @@
     }
 
-    /// \brief Erase more keys from the map and the inverse map.
-    ///
-    /// Erase more keys from the map and the inverse map. It is called by the
+    /// \brief Erase more keys from the map.
+    ///
+    /// Erase more keys from the map. It is called by the
     /// \c AlterationNotifier.
     virtual void erase(const std::vector<Key>& keys) {
@@ -2053 +2011 @@
     }
 
-    /// \brief Clear the keys from the map and the inverse map.
-    ///
-    /// Clear the keys from the map and the inverse map. It is called by the
+    /// \brief Clear the keys from the map and inverse map.
+    ///
+    /// Clear the keys from the map and inverse map. It is called by the
     /// \c AlterationNotifier.
     virtual void clear() {
@@ -2067 +2025 @@
     ///
     /// The inverse of this map. The subscript operator of the map
-    /// gives back the item that was last assigned to the value.
+    /// gives back always the item what was last assigned to the value.
     class InverseMap {
     public:
-      /// \brief Constructor
+      /// \brief Constructor of the InverseMap.
       ///
       /// Constructor of the InverseMap.
@@ -2083 +2041 @@
       /// \brief Subscript operator.
       ///
-      /// Subscript operator. It gives back the item
-      /// that was last assigned to the given value.
+      /// Subscript operator. It gives back always the item
+      /// what was last assigned to the value.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2093 +2051 @@
     };
 
-    /// \brief It gives back the read-only inverse map.
-    ///
-    /// It gives back the read-only inverse map.
+    /// \brief It gives back the just readable inverse map.
+    ///
+    /// It gives back the just readable inverse map.
     InverseMap inverse() const {
       return InverseMap(*this);
@@ -2103 +2061 @@
 
   /// \brief Provides a mutable, continuous and unique descriptor for each
-  /// item in a graph.
-  ///
-  /// DescriptorMap provides a unique and continuous (but mutable)
-  /// descriptor (id) for each item of the same type (\c Node, \c Arc or
-  /// \c Edge) in a graph. This id is
-  ///  - \b unique: different items get different ids,
-  ///  - \b continuous: the range of the ids is the set of integers
-  ///    between 0 and \c n-1, where \c n is the number of the items of
-  ///    this type (\c Node, \c Arc or \c Edge). So the id of an item can
-  ///    change if you delete an other item of the same type, i.e. this
-  ///    id is mutable.
-  ///
-  /// Thus this id is not (necessarily) the same as what can get using
-  /// 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.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IdMap
-  template <typename GR, typename K>
+  /// item in the graph.
+  ///
+  /// The DescriptorMap class provides a unique and continuous (but mutable)
+  /// descriptor (id) for each item of the same type (e.g. node) in the
+  /// graph. This id is <ul><li>\b unique: different items (nodes) get
+  /// different ids <li>\b continuous: the range of the ids is the set of
+  /// integers between 0 and \c n-1, where \c n is the number of the items of
+  /// this type (e.g. nodes) (so the id of a node can change if you delete an
+  /// other node, i.e. this id is mutable).  </ul> This map can be inverted
+  /// with its member class \c InverseMap, or with the \c operator() member.
+  ///
+  /// \tparam _Graph The graph class the \c DescriptorMap belongs to.
+  /// \tparam _Item The Item is the Key of the Map. It may be Node, Arc or
+  /// Edge.
+  template <typename _Graph, typename _Item>
   class DescriptorMap
-    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
-
-    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Map;
-
-  public:
-    /// The graph type of DescriptorMap.
-    typedef GR Graph;
-    /// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
-    typedef K Item;
-    /// The key type of DescriptorMap (\c Node, \c Arc or \c Edge).
-    typedef K Key;
+    : protected ItemSetTraits<_Graph, _Item>::template Map<int>::Type {
+
+    typedef _Item Item;
+    typedef typename ItemSetTraits<_Graph, _Item>::template Map<int>::Type Map;
+
+  public:
+    /// The graph class of DescriptorMap.
+    typedef _Graph Graph;
+
+    /// The key type of DescriptorMap (Node, Arc, Edge).
+    typedef typename Map::Key Key;
     /// The value type of DescriptorMap.
-    typedef int Value;
+    typedef typename Map::Value Value;
 
     /// \brief Constructor.
     ///
     /// Constructor for descriptor map.
-    explicit DescriptorMap(const Graph& gr) : Map(gr) {
+    explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
       Item it;
       const typename Map::Notifier* nf = Map::notifier();
@@ -2155 +2105 @@
   protected:
 
-    /// \brief Adds a new key to the map.
+    /// \brief Add a new key to the map.
     ///
     /// Add a new key to the map. It is called by the
@@ -2265 +2215 @@
 
   public:
-
     /// \brief The inverse map type of DescriptorMap.
     ///
@@ -2271 +2220 @@
     class InverseMap {
     public:
-      /// \brief Constructor
+      /// \brief Constructor of the InverseMap.
       ///
       /// Constructor of the InverseMap.
@@ -2286 +2235 @@
       ///
       /// Subscript operator. It gives back the item
-      /// that the descriptor currently belongs to.
+      /// that the descriptor belongs to currently.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2310 +2259 @@
   };
 
-  /// \brief Map of the source nodes of arcs in a digraph.
-  ///
-  /// SourceMap provides access for the source node of each arc in a digraph,
-  /// which is returned by the \c source() function of the digraph.
-  /// \tparam GR The digraph type.
+  /// \brief Returns the source of the given arc.
+  ///
+  /// The SourceMap gives back the source Node of the given arc.
   /// \see TargetMap
-  template <typename GR>
+  template <typename Digraph>
   class SourceMap {
   public:
 
-    ///\e
-    typedef typename GR::Arc Key;
-    ///\e
-    typedef typename GR::Node Value;
+    typedef typename Digraph::Node Value;
+    typedef typename Digraph::Arc Key;
 
     /// \brief Constructor
     ///
-    /// Constructor.
+    /// Constructor
     /// \param digraph The digraph that the map belongs to.
-    explicit SourceMap(const GR& digraph) : _graph(digraph) {}
-
-    /// \brief Returns the source node of the given arc.
-    ///
-    /// Returns the source node of the given arc.
+    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param arc The arc
+    /// \return The source of the arc
     Value operator[](const Key& arc) const {
-      return _graph.source(arc);
+      return _digraph.source(arc);
     }
 
   private:
-    const GR& _graph;
+    const Digraph& _digraph;
   };
 
@@ -2346 +2293 @@
   /// This function just returns an \c SourceMap class.
   /// \relates SourceMap
-  template <typename GR>
-  inline SourceMap<GR> sourceMap(const GR& graph) {
-    return SourceMap<GR>(graph);
-  }
-
-  /// \brief Map of the target nodes of arcs in a digraph.
-  ///
-  /// TargetMap provides access for the target node of each arc in a digraph,
-  /// which is returned by the \c target() function of the digraph.
-  /// \tparam GR The digraph type.
+  template <typename Digraph>
+  inline SourceMap<Digraph> sourceMap(const Digraph& digraph) {
+    return SourceMap<Digraph>(digraph);
+  }
+
+  /// \brief Returns the target of the given arc.
+  ///
+  /// The TargetMap gives back the target Node of the given arc.
   /// \see SourceMap
-  template <typename GR>
+  template <typename Digraph>
   class TargetMap {
   public:
 
-    ///\e
-    typedef typename GR::Arc Key;
-    ///\e
-    typedef typename GR::Node Value;
+    typedef typename Digraph::Node Value;
+    typedef typename Digraph::Arc Key;
 
     /// \brief Constructor
     ///
-    /// Constructor.
+    /// Constructor
     /// \param digraph The digraph that the map belongs to.
-    explicit TargetMap(const GR& digraph) : _graph(digraph) {}
-
-    /// \brief Returns the target node of the given arc.
-    ///
-    /// Returns the target node of the given arc.
+    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param e The arc
+    /// \return The target of the arc
     Value operator[](const Key& e) const {
-      return _graph.target(e);
+      return _digraph.target(e);
     }
 
   private:
-    const GR& _graph;
+    const Digraph& _digraph;
   };
 
@@ -2387 +2332 @@
   /// This function just returns a \c TargetMap class.
   /// \relates TargetMap
-  template <typename GR>
-  inline TargetMap<GR> targetMap(const GR& graph) {
-    return TargetMap<GR>(graph);
-  }
-
-  /// \brief Map of the "forward" directed arc view of edges in a graph.
-  ///
-  /// ForwardMap provides access for the "forward" directed arc view of
-  /// each edge in a graph, which is returned by the \c direct() function
-  /// of the graph with \c true parameter.
-  /// \tparam GR The graph type.
+  template <typename Digraph>
+  inline TargetMap<Digraph> targetMap(const Digraph& digraph) {
+    return TargetMap<Digraph>(digraph);
+  }
+
+  /// \brief Returns the "forward" directed arc view of an edge.
+  ///
+  /// Returns the "forward" directed arc view of an edge.
   /// \see BackwardMap
-  template <typename GR>
+  template <typename Graph>
   class ForwardMap {
   public:
 
-    typedef typename GR::Arc Value;
-    typedef typename GR::Edge Key;
+    typedef typename Graph::Arc Value;
+    typedef typename Graph::Edge Key;
 
     /// \brief Constructor
     ///
-    /// Constructor.
+    /// Constructor
     /// \param graph The graph that the map belongs to.
-    explicit ForwardMap(const GR& graph) : _graph(graph) {}
-
-    /// \brief Returns the "forward" directed arc view of the given edge.
-    ///
-    /// Returns the "forward" directed arc view of the given edge.
+    explicit ForwardMap(const Graph& graph) : _graph(graph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param key An edge
+    /// \return The "forward" directed arc view of edge
     Value operator[](const Key& key) const {
       return _graph.direct(key, true);
@@ -2420 +2364 @@
 
   private:
-    const GR& _graph;
+    const Graph& _graph;
   };
 
@@ -2427 +2371 @@
   /// This function just returns an \c ForwardMap class.
   /// \relates ForwardMap
-  template <typename GR>
-  inline ForwardMap<GR> forwardMap(const GR& graph) {
-    return ForwardMap<GR>(graph);
-  }
-
-  /// \brief Map of the "backward" directed arc view of edges in a graph.
-  ///
-  /// BackwardMap provides access for the "backward" directed arc view of
-  /// each edge in a graph, which is returned by the \c direct() function
-  /// of the graph with \c false parameter.
-  /// \tparam GR The graph type.
+  template <typename Graph>
+  inline ForwardMap<Graph> forwardMap(const Graph& graph) {
+    return ForwardMap<Graph>(graph);
+  }
+
+  /// \brief Returns the "backward" directed arc view of an edge.
+  ///
+  /// Returns the "backward" directed arc view of an edge.
   /// \see ForwardMap
-  template <typename GR>
+  template <typename Graph>
   class BackwardMap {
   public:
 
-    typedef typename GR::Arc Value;
-    typedef typename GR::Edge Key;
+    typedef typename Graph::Arc Value;
+    typedef typename Graph::Edge Key;
 
     /// \brief Constructor
     ///
-    /// Constructor.
+    /// Constructor
     /// \param graph The graph that the map belongs to.
-    explicit BackwardMap(const GR& graph) : _graph(graph) {}
-
-    /// \brief Returns the "backward" directed arc view of the given edge.
-    ///
-    /// Returns the "backward" directed arc view of the given edge.
+    explicit BackwardMap(const Graph& graph) : _graph(graph) {}
+
+    /// \brief The subscript operator.
+    ///
+    /// The subscript operator.
+    /// \param key An edge
+    /// \return The "backward" directed arc view of edge
     Value operator[](const Key& key) const {
       return _graph.direct(key, false);
@@ -2460 +2403 @@
 
   private:
-    const GR& _graph;
+    const Graph& _graph;
   };
 
@@ -2467 +2410 @@
   /// This function just returns a \c BackwardMap class.
   /// \relates BackwardMap
-  template <typename GR>
-  inline BackwardMap<GR> backwardMap(const GR& graph) {
-    return BackwardMap<GR>(graph);
-  }
-
-  /// \brief Map of the in-degrees of nodes in a digraph.
+  template <typename Graph>
+  inline BackwardMap<Graph> backwardMap(const Graph& graph) {
+    return BackwardMap<Graph>(graph);
+  }
+
+  /// \brief Potential difference map
+  ///
+  /// If there is an potential map on the nodes then we
+  /// can get an arc map as we get the substraction of the
+  /// values of the target and source.
+  template <typename Digraph, typename NodeMap>
+  class PotentialDifferenceMap {
+  public:
+    typedef typename Digraph::Arc Key;
+    typedef typename NodeMap::Value Value;
+
+    /// \brief Constructor
+    ///
+    /// Contructor of the map
+    explicit PotentialDifferenceMap(const Digraph& digraph,
+                                    const NodeMap& potential)
+      : _digraph(digraph), _potential(potential) {}
+
+    /// \brief Const subscription operator
+    ///
+    /// Const subscription operator
+    Value operator[](const Key& arc) const {
+      return _potential[_digraph.target(arc)] -
+        _potential[_digraph.source(arc)];
+    }
+
+  private:
+    const Digraph& _digraph;
+    const NodeMap& _potential;
+  };
+
+  /// \brief Returns a PotentialDifferenceMap.
+  ///
+  /// This function just returns a PotentialDifferenceMap.
+  /// \relates PotentialDifferenceMap
+  template <typename Digraph, typename NodeMap>
+  PotentialDifferenceMap<Digraph, NodeMap>
+  potentialDifferenceMap(const Digraph& digraph, const NodeMap& potential) {
+    return PotentialDifferenceMap<Digraph, NodeMap>(digraph, potential);
+  }
+
+  /// \brief Map of the node in-degrees.
   ///
   /// This map returns the in-degree of a node. Once it is constructed,
-  /// the degrees are stored in a standard \c NodeMap, so each query is done
+  /// the degrees are stored in a standard NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
-  /// \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
-  /// \ref ListDigraph::changeSource() "changeSource()",
+  /// \warning Besides addNode() and 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 \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
@@ -2489 +2472 @@
   ///
   /// \sa OutDegMap
-  template <typename GR>
+
+  template <typename _Digraph>
   class InDegMap
-    : protected ItemSetTraits<GR, typename GR::Arc>
+    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
-    
-    /// The digraph type
-    typedef GR Digraph;
-    /// The key type
+
+    typedef _Digraph Digraph;
+    typedef int Value;
     typedef typename Digraph::Node Key;
-    /// The value type
-    typedef int Value;
 
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
@@ -2543 +2524 @@
     /// \brief Constructor.
     ///
-    /// Constructor for creating an in-degree map.
-    explicit InDegMap(const Digraph& graph)
-      : _digraph(graph), _deg(graph) {
+    /// Constructor for creating in-degree map.
+    explicit InDegMap(const Digraph& digraph)
+      : _digraph(digraph), _deg(digraph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 
@@ -2553 +2534 @@
     }
 
-    /// \brief Gives back the in-degree of a Node.
-    ///
     /// Gives back the in-degree of a Node.
     int operator[](const Key& key) const {
@@ -2601 +2580 @@
   };
 
-  /// \brief Map of the out-degrees of nodes in a digraph.
+  /// \brief Map of the node out-degrees.
   ///
   /// This map returns the out-degree of a node. Once it is constructed,
-  /// the degrees are stored in a standard \c NodeMap, so each query is done
+  /// the degrees are stored in a standard NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
-  /// \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
-  /// \ref ListDigraph::changeSource() "changeSource()",
+  /// \warning Besides addNode() and 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 \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
@@ -2618 +2596 @@
   ///
   /// \sa InDegMap
-  template <typename GR>
+
+  template <typename _Digraph>
   class OutDegMap
-    : protected ItemSetTraits<GR, typename GR::Arc>
+    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
 
-    /// The digraph type
-    typedef GR Digraph;
-    /// The key type
+    typedef _Digraph Digraph;
+    typedef int Value;
     typedef typename Digraph::Node Key;
-    /// The value type
-    typedef int Value;
 
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
@@ -2670 +2646 @@
     /// \brief Constructor.
     ///
-    /// Constructor for creating an out-degree map.
-    explicit OutDegMap(const Digraph& graph)
-      : _digraph(graph), _deg(graph) {
+    /// Constructor for creating out-degree map.
+    explicit OutDegMap(const Digraph& digraph)
+      : _digraph(digraph), _deg(digraph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 
@@ -2680 +2656 @@
     }
 
-    /// \brief Gives back the out-degree of a Node.
-    ///
     /// Gives back the out-degree of a Node.
     int operator[](const Key& key) const {
@@ -2728 +2702 @@
   };
 
-  /// \brief Potential difference map
-  ///
-  /// PotentialMap returns the difference between the potentials of the
-  /// source and target nodes of each arc in a digraph, i.e. it returns
-  /// \code
-  ///   potential[gr.target(arc)] - potential[gr.source(arc)].
-  /// \endcode
-  /// \tparam GR The digraph type.
-  /// \tparam POT A node map storing the potentials.
-  template <typename GR, typename POT>
-  class PotentialDifferenceMap {
-  public:
-    /// Key type
-    typedef typename GR::Arc Key;
-    /// Value type
-    typedef typename POT::Value Value;
-
-    /// \brief Constructor
-    ///
-    /// Contructor of the map.
-    explicit PotentialDifferenceMap(const GR& gr,
-                                    const POT& potential)
-      : _digraph(gr), _potential(potential) {}
-
-    /// \brief Returns the potential difference for the given arc.
-    ///
-    /// Returns the potential difference for the given arc, i.e.
-    /// \code
-    ///   potential[gr.target(arc)] - potential[gr.source(arc)].
-    /// \endcode
-    Value operator[](const Key& arc) const {
-      return _potential[_digraph.target(arc)] -
-        _potential[_digraph.source(arc)];
-    }
-
-  private:
-    const GR& _digraph;
-    const POT& _potential;
-  };
-
-  /// \brief Returns a PotentialDifferenceMap.
-  ///
-  /// This function just returns a PotentialDifferenceMap.
-  /// \relates PotentialDifferenceMap
-  template <typename GR, typename POT>
-  PotentialDifferenceMap<GR, POT>
-  potentialDifferenceMap(const GR& gr, const POT& potential) {
-    return PotentialDifferenceMap<GR, POT>(gr, potential);
-  }
-
   /// @}
 }

lemon/max_matching.h

@@ -56 +56 @@
   /// decomposition() after running the algorithm.
   ///
-  /// \param GR The graph type the algorithm runs on.
-  template <typename GR>
+  /// \param _Graph The graph type the algorithm runs on.
+  template <typename _Graph>
   class MaxMatching {
   public:
 
-    typedef GR Graph;
+    typedef _Graph Graph;
     typedef typename Graph::template NodeMap<typename Graph::Arc>
     MatchingMap;
@@ -464 +464 @@
     /// map must have the property that there are no two incident edges
     /// with true value, ie. it contains a matching.
-    /// \return \c true if the map contains a matching.
+    /// \return %True if the map contains a matching.
     template <typename MatchingMap>
     bool matchingInit(const MatchingMap& matching) {
@@ -614 +614 @@
   /// maximum weighted matching algorithm. The implementation is based
   /// on extensive use of priority queues and provides
-  /// \f$O(nm\log n)\f$ time complexity.
+  /// \f$O(nm\log(n))\f$ time complexity.
   ///
   /// The maximum weighted matching problem is to find undirected
@@ -648 +648 @@
   /// of a blossom. If the value type is integral then the dual
   /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4".
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
+  template <typename _Graph,
+            typename _WeightMap = typename _Graph::template EdgeMap<int> >
   class MaxWeightedMatching {
   public:
 
-    ///\e
-    typedef GR Graph;
-    ///\e
-    typedef WM WeightMap;
-    ///\e
+    typedef _Graph Graph;
+    typedef _WeightMap WeightMap;
     typedef typename WeightMap::Value Value;
 
@@ -1961 +1958 @@
   /// maximum weighted perfect matching algorithm. The implementation
   /// is based on extensive use of priority queues and provides
-  /// \f$O(nm\log n)\f$ time complexity.
+  /// \f$O(nm\log(n))\f$ time complexity.
   ///
   /// The maximum weighted matching problem is to find undirected
@@ -1994 +1991 @@
   /// of a blossom. If the value type is integral then the dual
   /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4".
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
+  template <typename _Graph,
+            typename _WeightMap = typename _Graph::template EdgeMap<int> >
   class MaxWeightedPerfectMatching {
   public:
 
-    typedef GR Graph;
-    typedef WM WeightMap;
+    typedef _Graph Graph;
+    typedef _WeightMap WeightMap;
     typedef typename WeightMap::Value Value;
 

lemon/min_cost_arborescence.h

@@ -36 +36 @@
   ///
   /// Default traits class for MinCostArborescence class.
-  /// \param GR Digraph type.
-  /// \param CM Type of cost map.
-  template <class GR, class CM>
+  /// \param _Digraph Digraph type.
+  /// \param _CostMap Type of cost map.
+  template <class _Digraph, class _CostMap>
   struct MinCostArborescenceDefaultTraits{
 
     /// \brief The digraph type the algorithm runs on.
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
 
     /// \brief The type of the map that stores the arc costs.
@@ -48 +48 @@
     /// The type of the map that stores the arc costs.
     /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CM CostMap;
+    typedef _CostMap CostMap;
 
     /// \brief The value type of the costs.
@@ -64 +64 @@
     typedef typename Digraph::template ArcMap<bool> ArborescenceMap;
 
-    /// \brief Instantiates a \c ArborescenceMap.
-    ///
-    /// This function instantiates a \c ArborescenceMap.
+    /// \brief Instantiates a ArborescenceMap.
+    ///
+    /// This function instantiates a \ref ArborescenceMap.
     /// \param digraph is the graph, to which we would like to
-    /// calculate the \c ArborescenceMap.
+    /// calculate the ArborescenceMap.
     static ArborescenceMap *createArborescenceMap(const Digraph &digraph){
       return new ArborescenceMap(digraph);
     }
 
-    /// \brief The type of the \c PredMap
-    ///
-    /// The type of the \c PredMap. It is a node map with an arc value type.
+    /// \brief The type of the PredMap
+    ///
+    /// The type of the PredMap. It is a node map with an arc value type.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
 
-    /// \brief Instantiates a \c PredMap.
-    ///
-    /// This function instantiates a \c PredMap.
-    /// \param digraph The digraph to which we would like to define the
-    /// \c PredMap.
+    /// \brief Instantiates a PredMap.
+    ///
+    /// This function instantiates a \ref PredMap.
+    /// \param _digraph is the digraph, to which we would like to define the
+    /// PredMap.
     static PredMap *createPredMap(const Digraph &digraph){
       return new PredMap(digraph);
@@ -99 +99 @@
   /// the minimum cost subgraph which are union of arborescences with the
   /// given sources and spans all the nodes which are reachable from the
-  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
+  /// sources. The time complexity of the algorithm is \f$ O(n^2+e) \f$.
   ///
   /// The algorithm provides also an optimal dual solution, therefore
   /// the optimality of the solution can be checked.
   ///
-  /// \param GR The digraph type the algorithm runs on. The default value
+  /// \param _Digraph The digraph type the algorithm runs on. The default value
   /// is \ref ListDigraph.
-  /// \param CM This read-only ArcMap determines the costs of the
+  /// \param _CostMap This read-only ArcMap determines the costs of the
   /// arcs. It is read once for each arc, so the map may involve in
   /// relatively time consuming process to compute the arc cost if
   /// it is necessary. The default map type is \ref
   /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
-  /// \param TR Traits class to set various data types used
+  /// \param _Traits Traits class to set various data types used
   /// by the algorithm. The default traits class is
   /// \ref MinCostArborescenceDefaultTraits
-  /// "MinCostArborescenceDefaultTraits<GR, CM>".  See \ref
+  /// "MinCostArborescenceDefaultTraits<_Digraph, _CostMap>".  See \ref
   /// MinCostArborescenceDefaultTraits for the documentation of a
   /// MinCostArborescence traits class.
+  ///
+  /// \author Balazs Dezso
 #ifndef DOXYGEN
-  template <typename GR = ListDigraph,
-            typename CM = typename GR::template ArcMap<int>,
-            typename TR =
-              MinCostArborescenceDefaultTraits<GR, CM> >
+  template <typename _Digraph = ListDigraph,
+            typename _CostMap = typename _Digraph::template ArcMap<int>,
+            typename _Traits =
+            MinCostArborescenceDefaultTraits<_Digraph, _CostMap> >
 #else
-  template <typename GR, typename CM, typedef TR>
+  template <typename _Digraph, typename _CostMap, typedef _Traits>
 #endif
   class MinCostArborescence {
@@ -129 +131 @@
 
     /// The traits.
-    typedef TR Traits;
+    typedef _Traits Traits;
     /// The type of the underlying digraph.
     typedef typename Traits::Digraph Digraph;
@@ -439 +441 @@
     /// \brief Constructor.
     ///
-    /// \param digraph The digraph the algorithm will run on.
-    /// \param cost The cost map used by the algorithm.
+    /// \param _digraph The digraph the algorithm will run on.
+    /// \param _cost The cost map used by the algorithm.
     MinCostArborescence(const Digraph& digraph, const CostMap& cost)
       : _digraph(&digraph), _cost(&cost), _pred(0), local_pred(false),
@@ -455 +457 @@
     ///
     /// Sets the arborescence map.
-    /// \return <tt>(*this)</tt>
+    /// \return \c (*this)
     MinCostArborescence& arborescenceMap(ArborescenceMap& m) {
       if (local_arborescence) {
@@ -468 +470 @@
     ///
     /// Sets the arborescence map.
-    /// \return <tt>(*this)</tt>
+    /// \return \c (*this)
     MinCostArborescence& predMap(PredMap& m) {
       if (local_pred) {

lemon/path.h

@@ -41 +41 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -53 +53 @@
   /// implementation uses two vectors for storing the front and back
   /// insertions.
-  template <typename GR>
+  template <typename _Digraph>
   class Path {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -138 +138 @@
     /// \brief The nth arc.
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       return n < int(head.size()) ? *(head.rbegin() + n) :
@@ -146 +146 @@
     /// \brief Initialize arc iterator to point to the nth arc
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -229 +229 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -241 +241 @@
   /// then the \c Path type because it use just one vector for the
   /// arcs.
-  template <typename GR>
+  template <typename _Digraph>
   class SimplePath {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -330 +330 @@
     /// \brief The nth arc.
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       return data[n];
@@ -393 +393 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -405 +405 @@
   /// time. The front and back insertion and erasure is O(1) time
   /// and it can be splited and spliced in O(1) time.
-  template <typename GR>
+  template <typename _Digraph>
   class ListPath {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -508 +508 @@
     ///
     /// This function looks for the nth arc in O(n) time.
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       Node *node = first;
@@ -733 +733 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam GR The digraph type in which the path is.
+  /// \tparam _Digraph The digraph type in which the path is.
   ///
   /// In a sense, the path can be treated as a list of arcs. The
@@ -747 +747 @@
   /// it is intented to be
   /// used when you want to store a large number of paths.
-  template <typename GR>
+  template <typename _Digraph>
   class StaticPath {
   public:
 
-    typedef GR Digraph;
+    typedef _Digraph Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -834 +834 @@
     /// \brief The nth arc.
     ///
-    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
+    /// \pre n is in the [0..length() - 1] range
     const Arc& nth(int n) const {
       return arcs[n];

lemon/preflow.h

@@ -33 +33 @@
   /// Default traits class of Preflow class.
   /// \tparam GR Digraph type.
-  /// \tparam CAP Capacity map type.
-  template <typename GR, typename CAP>
+  /// \tparam CM Capacity map type.
+  template <typename GR, typename CM>
   struct PreflowDefaultTraits {
 
@@ -44 +44 @@
     /// The type of the map that stores the arc capacities.
     /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CAP CapacityMap;
+    typedef CM CapacityMap;
 
     /// \brief The type of the flow values.
@@ -95 +95 @@
   ///
   /// 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.
-  /// The preflow algorithms are the fastest known maximum
+  /// \e push-relabel algorithm producing a flow of maximum value in a
+  /// digraph. The preflow algorithms are the fastest known maximum
   /// flow algorithms. The current implementation use a mixture of the
   /// \e "highest label" and the \e "bound decrease" heuristics.
@@ -107 +106 @@
   ///
   /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CAP The type of the capacity map. The default map
+  /// \tparam CM The type of the capacity map. The default map
   /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 #ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TR>
+  template <typename GR, typename CM, typename TR>
 #else
   template <typename GR,
-            typename CAP = typename GR::template ArcMap<int>,
-            typename TR = PreflowDefaultTraits<GR, CAP> >
+            typename CM = typename GR::template ArcMap<int>,
+            typename TR = PreflowDefaultTraits<GR, CM> >
 #endif
   class Preflow {
@@ -196 +195 @@
     ///@{
 
-    template <typename T>
+    template <typename _FlowMap>
     struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
+      typedef _FlowMap FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
         LEMON_ASSERT(false, "FlowMap is not initialized");
@@ -210 +209 @@
     /// \ref named-templ-param "Named parameter" for setting FlowMap
     /// type.
-    template <typename T>
+    template <typename _FlowMap>
     struct SetFlowMap
-      : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<T> > {
+      : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<_FlowMap> > {
       typedef Preflow<Digraph, CapacityMap,
-                      SetFlowMapTraits<T> > Create;
+                      SetFlowMapTraits<_FlowMap> > Create;
     };
 
-    template <typename T>
+    template <typename _Elevator>
     struct SetElevatorTraits : public Traits {
-      typedef T Elevator;
+      typedef _Elevator Elevator;
       static Elevator *createElevator(const Digraph&, int) {
         LEMON_ASSERT(false, "Elevator is not initialized");
@@ -235 +234 @@
     /// \ref run() or \ref init().
     /// \sa SetStandardElevator
-    template <typename T>
+    template <typename _Elevator>
     struct SetElevator
-      : public Preflow<Digraph, CapacityMap, SetElevatorTraits<T> > {
+      : public Preflow<Digraph, CapacityMap, SetElevatorTraits<_Elevator> > {
       typedef Preflow<Digraph, CapacityMap,
-                      SetElevatorTraits<T> > Create;
+                      SetElevatorTraits<_Elevator> > Create;
     };
 
-    template <typename T>
+    template <typename _Elevator>
     struct SetStandardElevatorTraits : public Traits {
-      typedef T Elevator;
+      typedef _Elevator Elevator;
       static Elevator *createElevator(const Digraph& digraph, int max_level) {
         return new Elevator(digraph, max_level);
@@ -262 +261 @@
     /// before calling \ref run() or \ref init().
     /// \sa SetElevator
-    template <typename T>
+    template <typename _Elevator>
     struct SetStandardElevator
       : public Preflow<Digraph, CapacityMap,
-                       SetStandardElevatorTraits<T> > {
+                       SetStandardElevatorTraits<_Elevator> > {
       typedef Preflow<Digraph, CapacityMap,
-                      SetStandardElevatorTraits<T> > Create;
+                      SetStandardElevatorTraits<_Elevator> > Create;
     };
 
@@ -948 +947 @@
     ///
     /// \note This function calls \ref minCut() for each node, so it runs in
-    /// O(n) time.
+    /// \f$O(n)\f$ time.
     ///
     /// \pre Either \ref run() or \ref init() must be called before

lemon/radix_sort.h

@@ -206 +206 @@
   ///
   /// This is a special quick sort algorithm where the pivot
-  /// values to split the items are choosen to be 2<sup>k</sup>
-  /// for each \c k.
-  /// Therefore, the time complexity of the algorithm is O(log(c)*n) and
-  /// it uses O(log(c)) additional space, where \c c is the maximal value
-  /// and \c n is the number of the items in the container.
+  /// values to split the items are choosen to be \f$ 2^k \f$ for each \c k.
+  /// Therefore, the time complexity of the
+  /// algorithm is \f$ O(\log(c)n) \f$ and it uses \f$ O(\log(c)) \f$,
+  /// additional space, where \c c is the maximal value and \c n is the
+  /// number of the items in the container.
   ///
   /// \param first The begin of the given range.
@@ -431 +431 @@
   /// byte-by-byte. First, it counts how many times a byte value occurs
   /// in the container, then it copies the corresponding items to
-  /// another container in asceding order in O(n) time.
-  ///
-  /// The time complexity of the algorithm is O(log(c)*n) and
-  /// it uses O(n) additional space, where \c c is the
+  /// another container in asceding order in \c O(n) time.
+  ///
+  /// The time complexity of the algorithm is \f$ O(\log(c)n) \f$ and
+  /// it uses \f$ O(n) \f$, additional space, where \c c is the
   /// maximal value and \c n is the number of the items in the
   /// container.

lemon/random.h

@@ -604 +604 @@
     /// function with the <tt>/dev/urandom</tt> file. If it does not success,
     /// it uses the \c seedFromTime().
-    /// \return Currently always \c true.
+    /// \return Currently always true.
     bool seed() {
 #ifndef WIN32
@@ -625 +625 @@
     /// \param file The source file
     /// \param offset The offset, from the file read.
-    /// \return \c true when the seeding successes.
+    /// \return True when the seeding successes.
 #ifndef WIN32
     bool seedFromFile(const std::string& file = "/dev/urandom", int offset = 0)
@@ -646 +646 @@
     /// current process id and the current time for initialize the
     /// random sequence.
-    /// \return Currently always \c true.
+    /// \return Currently always true.
     bool seedFromTime() {
 #ifndef WIN32

lemon/smart_graph.h

@@ -226 +226 @@
     ///Add a new node to the digraph.
 
-    /// Add a new node to the digraph.
-    /// \return The new node.
+    /// \return the new node.
+    ///
     Node addNode() { return Parent::addNode(); }
 
@@ -234 +234 @@
     ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
-    ///\return The new arc.
+    ///\return the new arc.
     Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
@@ -667 +667 @@
     ///Add a new node to the graph.
 
-    /// Add a new node to the graph.
-    /// \return The new node.
+    /// \return the new node.
+    ///
     Node addNode() { return Parent::addNode(); }
 
@@ -675 +675 @@
     ///Add a new edge to the graph with node \c s
     ///and \c t.
-    ///\return The new edge.
+    ///\return the new edge.
     Edge addEdge(const Node& s, const Node& t) {
       return Parent::addEdge(s, t);

lemon/suurballe.h

@@ -46 +46 @@
   /// \ref CapacityScaling "successive shortest path" algorithm.
   ///
-  /// \tparam GR The digraph type the algorithm runs on.
+  /// \tparam Digraph The digraph type the algorithm runs on.
   /// The default value is \c ListDigraph.
-  /// \tparam LEN The type of the length (cost) map.
+  /// \tparam LengthMap The type of the length (cost) map.
   /// The default value is <tt>Digraph::ArcMap<int></tt>.
   ///
@@ -56 +56 @@
   /// with \ref SplitNodes.
 #ifdef DOXYGEN
-  template <typename GR, typename LEN>
+  template <typename Digraph, typename LengthMap>
 #else
-  template < typename GR = ListDigraph,
-             typename LEN = typename GR::template ArcMap<int> >
+  template < typename Digraph = ListDigraph,
+             typename LengthMap = typename Digraph::template ArcMap<int> >
 #endif
   class Suurballe
   {
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
+    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
+
+    typedef typename LengthMap::Value Length;
     typedef ConstMap<Arc, int> ConstArcMap;
-    typedef typename GR::template NodeMap<Arc> PredMap;
+    typedef typename Digraph::template NodeMap<Arc> PredMap;
 
   public:
 
-    /// The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
-    /// The type of the length map.
-    typedef LEN LengthMap;
-    /// The type of the lengths.
-    typedef typename LengthMap::Value Length;
     /// The type of the flow map.
     typedef typename Digraph::template ArcMap<int> FlowMap;
@@ -262 +257 @@
     /// the found arc-disjoint paths.
     ///
-    /// \return <tt>(*this)</tt>
+    /// \return \c (*this)
     Suurballe& flowMap(FlowMap &map) {
       if (_local_flow) {
@@ -279 +274 @@
     /// minimum cost flow problem.
     ///
-    /// \return <tt>(*this)</tt>
+    /// \return \c (*this)
     Suurballe& potentialMap(PotentialMap &map) {
       if (_local_potential) {
@@ -464 +459 @@
     ///
     /// This function returns the total length (cost) of the found paths
-    /// (flow). The complexity of the function is O(e).
+    /// (flow). The complexity of the function is \f$ O(e) \f$.
     ///
     /// \pre \ref run() or \ref findFlow() must be called before using

lemon/unionfind.h

@@ -52 +52 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  template <typename IM>
+  template <typename _ItemIntMap>
   class UnionFind {
   public:
 
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
+    typedef _ItemIntMap ItemIntMap;
     typedef typename ItemIntMap::Key Item;
 
@@ -173 +171 @@
   /// method.
   ///
-  template <typename IM>
+  template <typename _ItemIntMap>
   class UnionFindEnum {
   public:
 
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
+    typedef _ItemIntMap ItemIntMap;
     typedef typename ItemIntMap::Key Item;
 
@@ -632 +628 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  template <typename IM>
+  template <typename _ItemIntMap>
   class ExtendFindEnum {
   public:
 
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
+    typedef _ItemIntMap ItemIntMap;
     typedef typename ItemIntMap::Key Item;
 
@@ -955 +949 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  template <typename V, typename IM, typename Comp = std::less<V> >
+  ///
+  template <typename _Value, typename _ItemIntMap,
+            typename _Comp = std::less<_Value> >
   class HeapUnionFind {
   public:
 
-    ///\e
-    typedef V Value;
-    ///\e
-    typedef typename IM::Key Item;
-    ///\e
-    typedef IM ItemIntMap;
-    ///\e
-    typedef Comp Compare;
+    typedef _Value Value;
+    typedef typename _ItemIntMap::Key Item;
+
+    typedef _ItemIntMap ItemIntMap;
+
+    typedef _Comp Comp;
 
   private:
@@ -1608 +1602 @@
     /// \brief Gives back the priority of the current item.
     ///
-    /// Gives back the priority of the current item.
+    /// \return Gives back the priority of the current item.
     const Value& operator[](const Item& item) const {
       return nodes[index[item]].prio;
@@ -1653 +1647 @@
     /// \brief Gives back the minimum priority of the class.
     ///
-    /// Gives back the minimum priority of the class.
+    /// \return Gives back the minimum priority of the class.
     const Value& classPrio(int cls) const {
       return nodes[~(classes[cls].parent)].prio;
@@ -1667 +1661 @@
     /// \brief Gives back a representant item of the class.
     ///
-    /// Gives back a representant item of the class.
     /// The representant is indpendent from the priorities of the
     /// items.
+    /// \return Gives back a representant item of the class.
     const Item& classRep(int id) const {
       int parent = classes[id].parent;