Changeset 606:c5fd2d996909 in lemon for lemon

Timestamp:

03/29/09 23:08:20 (16 years ago)

Author:

Peter Kovacs <kpeter@…>

Branch:

default

Phase:

public

Message:

Various doc improvements (#248)

• Rename all the ugly template parameters (too long and/or starting with an underscore).
• Rename function parameters starting with an underscore.
• Extend the doc for many classes.
• Use LaTeX-style O(...) expressions only for the complicated ones.
• A lot of small unification changes.
• Small fixes.
• Some other improvements.

Location:

lemon

Files:

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

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 %ForwardMap).
-    template <typename ForwardMap, typename BackwardMap>
+    /// 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>
     class CombinedArcMap {
     public:
@@ -2264 +2265 @@
       typedef typename Parent::Arc Key;
       /// The value type of the map
-      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;
+      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;
 
       /// Constructor
-      CombinedArcMap(ForwardMap& forward, BackwardMap& backward)
+      CombinedArcMap(FW& forward, BK& backward)
         : _forward(&forward), _backward(&backward) {}
 
@@ -2306 +2307 @@
     protected:
 
-      ForwardMap* _forward;
-      BackwardMap* _backward;
+      FW* _forward;
+      BK* _backward;
 
     };
@@ -2314 +2315 @@
     ///
     /// This function just returns a combined arc map.
-    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);
+    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);
     }
 
@@ -3407 +3405 @@
     /// This map adaptor class adapts two node maps of the original digraph
     /// to get a node map of the split digraph.
-    /// Its value type is inherited from the first node map type
-    /// (\c InNodeMap).
-    template <typename InNodeMap, typename OutNodeMap>
+    /// 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>
     class CombinedNodeMap {
     public:
@@ -3416 +3415 @@
       typedef Node Key;
       /// The value type of the map
-      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;
+      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;
 
       /// Constructor
-      CombinedNodeMap(InNodeMap& in_map, OutNodeMap& out_map)
+      CombinedNodeMap(IN& in_map, OUT& out_map)
         : _in_map(in_map), _out_map(out_map) {}
 
@@ -3457 +3456 @@
     private:
 
-      InNodeMap& _in_map;
-      OutNodeMap& _out_map;
+      IN& _in_map;
+      OUT& _out_map;
 
     };
@@ -3466 +3465 @@
     ///
     /// This function just returns a combined node 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);
+    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);
     }
 
@@ -3496 +3494 @@
     /// This map adaptor class adapts an arc map and a node map of the
     /// original digraph to get an arc map of the split digraph.
-    /// Its value type is inherited from the original arc map type
-    /// (\c ArcMap).
-    template <typename ArcMap, typename NodeMap>
+    /// 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>
     class CombinedArcMap {
     public:
@@ -3505 +3504 @@
       typedef Arc Key;
       /// The value type of the map
-      typedef typename ArcMap::Value Value;
-
-      typedef typename MapTraits<ArcMap>::ReferenceMapTag ReferenceMapTag;
-      typedef typename MapTraits<ArcMap>::ReturnValue ReturnValue;
-      typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReturnValue;
-      typedef typename MapTraits<ArcMap>::ReturnValue Reference;
-      typedef typename MapTraits<ArcMap>::ConstReturnValue ConstReference;
+      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;
 
       /// Constructor
-      CombinedArcMap(ArcMap& arc_map, NodeMap& node_map)
+      CombinedArcMap(AM& arc_map, NM& node_map)
         : _arc_map(arc_map), _node_map(node_map) {}
 
@@ -3545 +3544 @@
 
     private:
-      ArcMap& _arc_map;
-      NodeMap& _node_map;
+
+      AM& _arc_map;
+      NM& _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 Compare 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 Comp specifies the ordering of the priorities.
+  ///In a heap one can change the priority of an item, add or erase an
+  ///item, etc.
   ///
-  ///\tparam _Prio Type of the priority of the items.
-  ///\tparam _ItemIntMap A read and writable Item int map, used internally
+  ///\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 _Compare A class for the ordering of the priorities. The
-  ///default is \c std::less<_Prio>.
+  ///\tparam Comp A functor class for the ordering of the priorities.
+  ///The default is \c std::less<PR>.
   ///
   ///\sa FibHeap
   ///\sa Dijkstra
-  template <typename _Prio, typename _ItemIntMap,
-            typename _Compare = std::less<_Prio> >
+  template <typename PR, typename IM, typename Comp = std::less<PR> >
   class BinHeap {
 
   public:
     ///\e
-    typedef _ItemIntMap ItemIntMap;
-    ///\e
-    typedef _Prio Prio;
+    typedef IM ItemIntMap;
+    ///\e
+    typedef PR Prio;
     ///\e
     typedef typename ItemIntMap::Key Item;
@@ -62 +63 @@
     typedef std::pair<Item,Prio> Pair;
     ///\e
-    typedef _Compare Compare;
+    typedef Comp Compare;
 
     /// \brief Type to represent the items states.
@@ -70 +71 @@
     /// heap's point of view, but may be useful to the user.
     ///
-    /// The ItemIntMap \e should be initialized in such way that it maps
-    /// PRE_HEAP (-1) to any element to be put in the heap...
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
     enum State {
-      IN_HEAP = 0,
-      PRE_HEAP = -1,
-      POST_HEAP = -2
+      IN_HEAP = 0,    ///< \e
+      PRE_HEAP = -1,  ///< \e
+      POST_HEAP = -2  ///< \e
     };
 
   private:
-    std::vector<Pair> data;
-    Compare comp;
-    ItemIntMap &iim;
+    std::vector<Pair> _data;
+    Compare _comp;
+    ItemIntMap &_iim;
 
   public:
@@ -87 +88 @@
     ///
     /// The constructor.
-    /// \param _iim should be given to the constructor, since it is used
+    /// \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
     /// internally to handle the cross references. The value of the map
     /// should be PRE_HEAP (-1) for each element.
-    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) {}
+    ///
+    /// \param comp The comparator function object.
+    BinHeap(ItemIntMap &map, const Compare &comp)
+      : _iim(map), _comp(comp) {}
 
 
@@ -107 +108 @@
     ///
     /// \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.
@@ -121 +122 @@
     /// each item to \c PRE_HEAP.
     void clear() {
-      data.clear();
+      _data.clear();
     }
 
@@ -129 +130 @@
     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);
@@ -146 +147 @@
       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;
       }
@@ -166 +167 @@
 
     void move(const Pair &p, int i) {
-      data[i] = p;
-      iim.set(p.first, i);
+      _data[i] = p;
+      _iim.set(p.first, i);
     }
 
@@ -176 +177 @@
     /// \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);
     }
@@ -194 +195 @@
     /// \pre The heap must be nonempty.
     Item top() const {
-      return data[0].first;
+      return _data[0].first;
     }
 
@@ -202 +203 @@
     /// \pre The heap must be nonempty.
     Prio prio() const {
-      return data[0].second;
+      return _data[0].second;
     }
 
@@ -211 +212 @@
     /// \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();
     }
 
@@ -225 +226 @@
     /// \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();
     }
 
@@ -240 +241 @@
     ///
     /// 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;
     }
 
@@ -255 +256 @@
     /// \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());
       }
     }
@@ -270 +271 @@
     ///
     /// 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.
+    void decrease(const Item &i, const Prio &p) {
+      int idx = _iim[i];
+      bubble_up(idx, Pair(i,p));
+    }
+
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
     /// \param i The item.
     /// \param p The priority.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = iim[i];
-      bubble_up(idx, Pair(i,p));
-    }
-
-    /// \brief Increases the priority of \c i to \c p.
-    ///
-    /// This method sets the priority of item \c i to \c p.
     /// \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());
     }
 
@@ -300 +301 @@
     /// \param i The item.
     State state(const Item &i) const {
-      int s = iim[i];
+      int s = _iim[i];
       if( s>=0 )
         s=0;
@@ -320 +321 @@
           erase(i);
         }
-        iim[i] = st;
+        _iim[i] = st;
         break;
       case IN_HEAP:
@@ -334 +335 @@
     /// 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;
 
-    /// \brief Gives back the arc alteration notifier.
-    ///
-    /// Gives back the arc alteration notifier.
+    // Gives back the arc alteration notifier.
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
@@ -186 +184 @@
     };
 
-    /// \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));
@@ -272 +270 @@
 
 
-  /// \ingroup digraphbits
-  ///
-  /// \brief Extender for the EdgeSets
+  // \ingroup digraphbits
+  //
+  // \brief Extender for the EdgeSets
   template <typename Base>
   class EdgeSetExtender : public Base {
@@ -493 +491 @@
     };
 
-    /// \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 _FlowMap>
+    template <typename T>
     struct SetFlowMapTraits : public Traits {
-      typedef _FlowMap FlowMap;
+      typedef T 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 _FlowMap>
+    template <typename T>
     struct SetFlowMap
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                           SetFlowMapTraits<_FlowMap> > {
+                           SetFlowMapTraits<T> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                          SetFlowMapTraits<_FlowMap> > Create;
+                          SetFlowMapTraits<T> > Create;
     };
 
-    template <typename _Elevator>
+    template <typename T>
     struct SetElevatorTraits : public Traits {
-      typedef _Elevator Elevator;
+      typedef T 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 _Elevator>
+    template <typename T>
     struct SetElevator
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                           SetElevatorTraits<_Elevator> > {
+                           SetElevatorTraits<T> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                          SetElevatorTraits<_Elevator> > Create;
+                          SetElevatorTraits<T> > Create;
     };
 
-    template <typename _Elevator>
+    template <typename T>
     struct SetStandardElevatorTraits : public Traits {
-      typedef _Elevator Elevator;
+      typedef T 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 _Elevator>
+    template <typename T>
     struct SetStandardElevator
       : public Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                       SetStandardElevatorTraits<_Elevator> > {
+                       SetStandardElevatorTraits<T> > {
       typedef Circulation<Digraph, LCapMap, UCapMap, DeltaMap,
-                      SetStandardElevatorTraits<_Elevator> > Create;
+                      SetStandardElevatorTraits<T> > Create;
     };
 
@@ -683 +683 @@
     ///
     /// \note This function calls \ref barrier() for each node,
-    /// so it runs in \f$O(n)\f$ time.
+    /// so it runs in O(n) 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. 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
+      /// 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 direction
+      /// \sa v()
+      /// \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
@@ -45 +44 @@
 
 #ifndef DOXYGEN
-    template <char _selector = '0'>
+    template <char sel = '0'>
 #endif
     class GraphItem {
@@ -297 +296 @@
     /// The most of the base digraphs should conform to this concept.
     /// The id's are unique and immutable.
-    template <typename _Base = BaseDigraphComponent>
-    class IDableDigraphComponent : public _Base {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class IDableDigraphComponent : public BAS {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -375 +374 @@
     /// most of the base undirected graphs should conform to this
     /// concept.  The id's are unique and immutable.
-    template <typename _Base = BaseGraphComponent>
-    class IDableGraphComponent : public IDableDigraphComponent<_Base> {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class IDableGraphComponent : public IDableDigraphComponent<BAS> {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Edge Edge;
 
-      using IDableDigraphComponent<_Base>::id;
+      using IDableDigraphComponent<Base>::id;
 
       /// \brief Gives back an unique integer id for the Edge.
@@ -426 +425 @@
     /// Skeleton class for graph NodeIt and ArcIt.
     ///
-    template <typename _Graph, typename _Item>
-    class GraphItemIt : public _Item {
+    template <typename GR, typename Item>
+    class GraphItemIt : public Item {
     public:
       /// \brief Default constructor.
@@ -443 +442 @@
       /// Sets the iterator to the first item of \c the graph.
       ///
-      explicit GraphItemIt(const _Graph&) {}
+      explicit GraphItemIt(const GR&) {}
       /// \brief Invalid constructor \& conversion.
       ///
@@ -480 +479 @@
           ++(++it1);
 
-          _Item bi = it1;
+          Item bi = it1;
           bi = it2;
         }
-        _Graph& g;
+        GR& g;
       };
     };
@@ -490 +489 @@
     ///
     /// \note Because InArcIt and OutArcIt may not inherit from the same
-    /// base class, the _selector is a additional template parameter. For
-    /// InArcIt you should instantiate it with character 'i' and for
+    /// base class, the \c sel is a additional template parameter (selector).
+    /// For InArcIt you should instantiate it with character 'i' and for
     /// OutArcIt with 'o'.
-    template <typename _Graph,
-              typename _Item = typename _Graph::Arc,
-              typename _Base = typename _Graph::Node,
-              char _selector = '0'>
-    class GraphIncIt : public _Item {
+    template <typename GR,
+              typename Item = typename GR::Arc,
+              typename Base = typename GR::Node,
+              char sel = '0'>
+    class GraphIncIt : public Item {
     public:
       /// \brief Default constructor.
@@ -508 +507 @@
       /// 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.
@@ -515 +514 @@
       /// from the node.
       ///
-      explicit GraphIncIt(const _Graph&, const _Base&) {}
+      explicit GraphIncIt(const GR&, const Base&) {}
       /// \brief Invalid constructor \& conversion.
       ///
@@ -547 +546 @@
       struct Constraints {
         void constraints() {
-          checkConcept<GraphItem<_selector>, _GraphIncIt>();
+          checkConcept<GraphItem<sel>, _GraphIncIt>();
           _GraphIncIt it1(graph, node);
           _GraphIncIt it2;
@@ -554 +553 @@
           ++it2 = it1;
           ++(++it1);
-          _Item e = it1;
+          Item e = it1;
           e = it2;
 
         }
 
-        _Item arc;
-        _Base node;
-        _Graph graph;
+        Item arc;
+        Base node;
+        GR graph;
         _GraphIncIt it;
       };
@@ -572 +571 @@
     /// iterator based iterable interface for the digraph structure.
     /// This concept is part of the Digraph concept.
-    template <typename _Base = BaseDigraphComponent>
-    class IterableDigraphComponent : public _Base {
-
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class IterableDigraphComponent : public BAS {
+
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -757 +756 @@
     /// based iterable interface for the undirected graph structure.
     /// This concept is part of the Graph concept.
-    template <typename _Base = BaseGraphComponent>
-    class IterableGraphComponent : public IterableDigraphComponent<_Base> {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class IterableGraphComponent : public IterableDigraphComponent<BAS> {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -774 +773 @@
       /// @{
 
-      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
@@ -809 +808 @@
       void nextInc(Edge&, bool&) const {}
 
-      using IterableDigraphComponent<_Base>::baseNode;
-      using IterableDigraphComponent<_Base>::runningNode;
+      using IterableDigraphComponent<Base>::baseNode;
+      using IterableDigraphComponent<Base>::runningNode;
 
       /// @}
@@ -876 +875 @@
 
         const _Graph& graph;
-
       };
     };
@@ -888 +886 @@
     /// alteration occured in the digraph all the observers will
     /// notified about it.
-    template <typename _Base = BaseDigraphComponent>
-    class AlterableDigraphComponent : public _Base {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class AlterableDigraphComponent : public BAS {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -946 +944 @@
     /// alteration occured in the graph all the observers will
     /// notified about it.
-    template <typename _Base = BaseGraphComponent>
-    class AlterableGraphComponent : public AlterableDigraphComponent<_Base> {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class AlterableGraphComponent : public AlterableDigraphComponent<BAS> {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Edge Edge;
 
@@ -975 +973 @@
 
         const _Graph& graph;
-
-      };
-
+      };
     };
 
@@ -985 +981 @@
     /// (NodeMap, ArcMap), that is maps that can be used to
     /// associate data to graph descriptors (nodes or arcs).
-    template <typename _Graph, typename _Item, typename _Value>
-    class GraphMap : public ReadWriteMap<_Item, _Value> {
-    public:
-
-      typedef ReadWriteMap<_Item, _Value> Parent;
+    template <typename GR, typename K, typename V>
+    class GraphMap : public ReadWriteMap<K, V> {
+    public:
+
+      typedef ReadWriteMap<K, V> Parent;
 
       /// The graph type of the map.
-      typedef _Graph Graph;
+      typedef GR Graph;
       /// The key type of the map.
-      typedef _Item Key;
+      typedef K Key;
       /// The value type of the map.
-      typedef _Value Value;
+      typedef V Value;
 
       /// \brief Construct a new map.
@@ -1056 +1052 @@
     /// map interface for the digraph structure.
     /// This concept is part of the Digraph concept.
-    template <typename _Base = BaseDigraphComponent>
-    class MappableDigraphComponent : public _Base  {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class MappableDigraphComponent : public BAS  {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -1070 +1066 @@
       /// ReadWrite map of the nodes.
       ///
-      template <typename _Value>
-      class NodeMap : public GraphMap<Digraph, Node, _Value> {
+      template <typename V>
+      class NodeMap : public GraphMap<Digraph, Node, V> {
       public:
-        typedef GraphMap<MappableDigraphComponent, Node, _Value> Parent;
+        typedef GraphMap<MappableDigraphComponent, Node, V> Parent;
 
         /// \brief Construct a new map.
@@ -1084 +1080 @@
         ///
         /// Construct a new map for the digraph and initalise the values.
-        NodeMap(const MappableDigraphComponent& digraph, const _Value& value)
+        NodeMap(const MappableDigraphComponent& digraph, const V& value)
           : Parent(digraph, value) {}
 
@@ -1098 +1094 @@
         template <typename CMap>
         NodeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Node, _Value>, CMap>();
+          checkConcept<ReadMap<Node, V>, CMap>();
           return *this;
         }
@@ -1108 +1104 @@
       /// ReadWrite map of the arcs.
       ///
-      template <typename _Value>
-      class ArcMap : public GraphMap<Digraph, Arc, _Value> {
+      template <typename V>
+      class ArcMap : public GraphMap<Digraph, Arc, V> {
       public:
-        typedef GraphMap<MappableDigraphComponent, Arc, _Value> Parent;
+        typedef GraphMap<MappableDigraphComponent, Arc, V> Parent;
 
         /// \brief Construct a new map.
@@ -1122 +1118 @@
         ///
         /// Construct a new map for the digraph and initalise the values.
-        ArcMap(const MappableDigraphComponent& digraph, const _Value& value)
+        ArcMap(const MappableDigraphComponent& digraph, const V& value)
           : Parent(digraph, value) {}
 
@@ -1136 +1132 @@
         template <typename CMap>
         ArcMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Arc, _Value>, CMap>();
+          checkConcept<ReadMap<Arc, V>, CMap>();
           return *this;
         }
@@ -1192 +1188 @@
     /// map interface for the graph structure.
     /// This concept is part of the Graph concept.
-    template <typename _Base = BaseGraphComponent>
-    class MappableGraphComponent : public MappableDigraphComponent<_Base>  {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class MappableGraphComponent : public MappableDigraphComponent<BAS>  {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Edge Edge;
 
@@ -1205 +1201 @@
       /// ReadWrite map of the edges.
       ///
-      template <typename _Value>
-      class EdgeMap : public GraphMap<Graph, Edge, _Value> {
+      template <typename V>
+      class EdgeMap : public GraphMap<Graph, Edge, V> {
       public:
-        typedef GraphMap<MappableGraphComponent, Edge, _Value> Parent;
+        typedef GraphMap<MappableGraphComponent, Edge, V> Parent;
 
         /// \brief Construct a new map.
@@ -1219 +1215 @@
         ///
         /// Construct a new map for the graph and initalise the values.
-        EdgeMap(const MappableGraphComponent& graph, const _Value& value)
+        EdgeMap(const MappableGraphComponent& graph, const V& value)
           : Parent(graph, value) {}
 
@@ -1233 +1229 @@
         template <typename CMap>
         EdgeMap& operator=(const CMap&) {
-          checkConcept<ReadMap<Edge, _Value>, CMap>();
+          checkConcept<ReadMap<Edge, V>, CMap>();
           return *this;
         }
@@ -1277 +1273 @@
     /// difference between the base and this interface is that the
     /// digraph alterations should handled already on this level.
-    template <typename _Base = BaseDigraphComponent>
-    class ExtendableDigraphComponent : public _Base {
-    public:
-      typedef _Base Base;
-
-      typedef typename _Base::Node Node;
-      typedef typename _Base::Arc Arc;
+    template <typename BAS = BaseDigraphComponent>
+    class ExtendableDigraphComponent : public BAS {
+    public:
+      typedef BAS Base;
+
+      typedef typename Base::Node Node;
+      typedef typename Base::Arc Arc;
 
       /// \brief Adds a new node to the digraph.
@@ -1322 +1318 @@
     /// that the graph alterations should handled already on this
     /// level.
-    template <typename _Base = BaseGraphComponent>
-    class ExtendableGraphComponent : public _Base {
-    public:
-
-      typedef _Base Base;
-      typedef typename _Base::Node Node;
-      typedef typename _Base::Edge Edge;
+    template <typename BAS = BaseGraphComponent>
+    class ExtendableGraphComponent : public BAS {
+    public:
+
+      typedef BAS Base;
+      typedef typename Base::Node Node;
+      typedef typename Base::Edge Edge;
 
       /// \brief Adds a new node to the graph.
@@ -1366 +1362 @@
     /// the base and this interface is that the digraph alterations
     /// should handled already on this level.
-    template <typename _Base = BaseDigraphComponent>
-    class ErasableDigraphComponent : public _Base {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class ErasableDigraphComponent : public BAS {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Arc Arc;
@@ -1406 +1402 @@
     /// main difference between the base and this interface is that
     /// the graph alterations should handled already on this level.
-    template <typename _Base = BaseGraphComponent>
-    class ErasableGraphComponent : public _Base {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class ErasableGraphComponent : public BAS {
+    public:
+
+      typedef BAS Base;
       typedef typename Base::Node Node;
       typedef typename Base::Edge Edge;
@@ -1446 +1442 @@
     /// the base and this interface is that the digraph alterations
     /// should handled already on this level.
-    template <typename _Base = BaseDigraphComponent>
-    class ClearableDigraphComponent : public _Base {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseDigraphComponent>
+    class ClearableDigraphComponent : public BAS {
+    public:
+
+      typedef BAS Base;
 
       /// \brief Erase all nodes and arcs from the digraph.
@@ -1475 +1471 @@
     /// main difference between the base and this interface is that
     /// the graph alterations should handled already on this level.
-    template <typename _Base = BaseGraphComponent>
-    class ClearableGraphComponent : public ClearableDigraphComponent<_Base> {
-    public:
-
-      typedef _Base Base;
+    template <typename BAS = BaseGraphComponent>
+    class ClearableGraphComponent : public ClearableDigraphComponent<BAS> {
+    public:
+
+      typedef BAS Base;
 
       template <typename _Graph>

lemon/concepts/heap.h

@@ -36 +36 @@
     /// \brief The heap concept.
     ///
-    /// Concept class describing the main interface of heaps.
-    template <typename Priority, typename ItemIntMap>
+    /// 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
     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.
@@ -54 +69 @@
       /// the user.
       ///
-      /// The \c ItemIntMap must be initialized in such a way, that it
-      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
+      /// The item-int map must be initialized in such way that it assigns
+      /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
       enum State {
-        IN_HEAP = 0,
-        PRE_HEAP = -1,
-        POST_HEAP = -2
+        IN_HEAP = 0,    ///< The "in heap" state constant.
+        PRE_HEAP = -1,  ///< The "pre heap" state constant.
+        POST_HEAP = -2  ///< The "post heap" state constant.
       };
 
@@ -120 +135 @@
       ///
       /// 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 {}
 
@@ -138 +153 @@
       ///
       /// Decreases the priority of an item to the given value.
+      /// \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) {}
+
+      /// \brief Increases the priority of an item to the given value.
+      ///
+      /// Increases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
-      void decrease(const Item &i, const Prio &p) {}
-
-      /// \brief Increases the priority of an item to the given value.
-      ///
-      /// 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.
       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 _Digraph The digraph type in which the path is.
+    /// \tparam GR 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 _Digraph>
+    template <typename GR>
     class Path {
     public:
 
       /// Type of the underlying digraph.
-      typedef _Digraph Digraph;
+      typedef GR 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 _Digraph  The digraph type in which the path is.
+    ///
+    /// \tparam GR The digraph type in which the path is.
     ///
     /// The paths can be constructed from any path type by a
     /// template constructor or a template assignment operator.
-    ///
-    template <typename _Digraph>
+    template <typename GR>
     class PathDumper {
     public:
 
       /// Type of the underlying digraph.
-      typedef _Digraph Digraph;
+      typedef GR 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 %True when there is path between any two nodes in the graph.
+  /// \return \c 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 %False when the graph is not strongly connected.
+  /// \return \c false when the graph is not strongly connected.
   /// \see connected
   ///
@@ -710 +710 @@
   ///
   /// \param graph The graph.
-  /// \return %True when the graph bi-node-connected.
+  /// \return \c 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 %False when the graph is not DAG.
+  /// \return \c 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 %False when the graph is not DAG.
+  /// \return \c 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 %True when there is no circle in the graph.
+  /// \return \c 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 %True when the graph is acyclic and connected.
+  /// \return \c 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 %True if \c graph is bipartite, %false otherwise.
+  /// \return \c true if \c graph is bipartite, \c 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 %True if \c graph is bipartite, %false otherwise.
+  /// \return \c true if \c graph is bipartite, \c 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 _Graph>
-  class ConArcIt : public _Graph::Arc {
+  template <typename GR>
+  class ConArcIt : public GR::Arc {
   public:
 
-    typedef _Graph Graph;
+    typedef GR Graph;
     typedef typename Graph::Arc Parent;
 
@@ -1158 +1158 @@
   ///
   ///\sa findEdge()
-  template <typename _Graph>
-  class ConEdgeIt : public _Graph::Edge {
+  template <typename GR>
+  class ConEdgeIt : public GR::Edge {
   public:
 
-    typedef _Graph Graph;
+    typedef GR Graph;
     typedef typename Graph::Edge Parent;
 
@@ -1212 +1212 @@
   ///queries.
   ///
-  ///\tparam G The type of the underlying digraph.
+  ///\tparam GR The type of the underlying digraph.
   ///
   ///\sa ArcLookUp
   ///\sa AllArcLookUp
-  template<class G>
+  template <typename GR>
   class DynArcLookUp
-    : protected ItemSetTraits<G, typename G::Arc>::ItemNotifier::ObserverBase
+    : protected ItemSetTraits<GR, typename GR::Arc>::ItemNotifier::ObserverBase
   {
   public:
-    typedef typename ItemSetTraits<G, typename G::Arc>
+    typedef typename ItemSetTraits<GR, typename GR::Arc>
     ::ItemNotifier::ObserverBase Parent;
 
-    TEMPLATE_DIGRAPH_TYPEDEFS(G);
-    typedef G Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+    typedef GR Digraph;
 
   protected:
 
-    class AutoNodeMap : public ItemSetTraits<G, Node>::template Map<Arc>::Type {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
     public:
 
-      typedef typename ItemSetTraits<G, Node>::template Map<Arc>::Type Parent;
-
-      AutoNodeMap(const G& digraph) : Parent(digraph, INVALID) {}
+      typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
+
+      AutoNodeMap(const GR& 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 G The type of the underlying digraph.
+  ///\tparam GR The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa AllArcLookUp
-  template<class G>
+  template<class GR>
   class ArcLookUp
   {
   public:
-    TEMPLATE_DIGRAPH_TYPEDEFS(G);
-    typedef G Digraph;
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+    typedef GR Digraph;
 
   protected:
@@ -1734 +1734 @@
   ///(<em>O</em>(<em>m</em> log<em>m</em>)) to the number of arcs).
   ///
-  ///\tparam G The type of the underlying digraph.
+  ///\tparam GR The type of the underlying digraph.
   ///
   ///\sa DynArcLookUp
   ///\sa ArcLookUp
-  template<class G>
-  class AllArcLookUp : public ArcLookUp<G>
+  template<class GR>
+  class AllArcLookUp : public ArcLookUp<GR>
   {
-    using ArcLookUp<G>::_g;
-    using ArcLookUp<G>::_right;
-    using ArcLookUp<G>::_left;
-    using ArcLookUp<G>::_head;
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(G);
-    typedef G Digraph;
+    using ArcLookUp<GR>::_g;
+    using ArcLookUp<GR>::_right;
+    using ArcLookUp<GR>::_left;
+    using ArcLookUp<GR>::_head;
+
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+    typedef GR 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<G>(g), _next(g) {refreshNext();}
+    AllArcLookUp(const Digraph &g) : ArcLookUp<GR>(g), _next(g) {refreshNext();}
 
     ///Refresh the data structure at a node.
@@ -1784 +1784 @@
     void refresh(Node n)
     {
-      ArcLookUp<G>::refresh(n);
+      ArcLookUp<GR>::refresh(n);
       refreshNext(_head[n]);
     }
@@ -1831 +1831 @@
     Arc operator()(Node s, Node t, Arc prev=INVALID) const {}
 #else
-    using ArcLookUp<G>::operator() ;
+    using ArcLookUp<GR>::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 Value>
+  template <typename V>
   struct DijkstraDefaultOperationTraits {
+    /// \e
+    typedef V Value;
     /// \brief Gives back the zero value of the type.
     static Value zero() {
@@ -59 +61 @@
   ///Default traits class of Dijkstra class.
   ///\tparam GR The type of the digraph.
-  ///\tparam LM The type of the length map.
-  template<class GR, class LM>
+  ///\tparam LEN The type of the length map.
+  template<typename GR, typename LEN>
   struct DijkstraDefaultTraits
   {
@@ -70 +72 @@
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LM LengthMap;
+    typedef LEN LengthMap;
     ///The type of the length of the arcs.
-    typedef typename LM::Value Value;
+    typedef typename LEN::Value Value;
 
     /// Operation traits for %Dijkstra algorithm.
@@ -101 +103 @@
     ///\sa BinHeap
     ///\sa Dijkstra
-    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
+    typedef BinHeap<typename LEN::Value, HeapCrossRef, std::less<Value> > Heap;
     ///Instantiates a \c Heap.
 
@@ -151 +153 @@
     ///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 LM::Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a \c DistMap.
 
@@ -181 +183 @@
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
-  ///\tparam LM A \ref concepts::ReadMap "readable" arc map that specifies
+  ///\tparam LEN 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
@@ -188 +190 @@
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
 #ifdef DOXYGEN
-  template <typename GR, typename LM, typename TR>
+  template <typename GR, typename LEN, typename TR>
 #else
   template <typename GR=ListDigraph,
-            typename LM=typename GR::template ArcMap<int>,
-            typename TR=DijkstraDefaultTraits<GR,LM> >
+            typename LEN=typename GR::template ArcMap<int>,
+            typename TR=DijkstraDefaultTraits<GR,LEN> >
 #endif
   class Dijkstra {
@@ -914 +916 @@
   ///Default traits class of dijkstra() function.
   ///\tparam GR The type of the digraph.
-  ///\tparam LM The type of the length map.
-  template<class GR, class LM>
+  ///\tparam LEN The type of the length map.
+  template<class GR, class LEN>
   struct DijkstraWizardDefaultTraits
   {
@@ -924 +926 @@
     ///The type of the map that stores the arc lengths.
     ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LM LengthMap;
+    typedef LEN LengthMap;
     ///The type of the length of the arcs.
-    typedef typename LM::Value Value;
+    typedef typename LEN::Value Value;
 
     /// Operation traits for Dijkstra algorithm.
@@ -1008 +1010 @@
     ///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 LM::Value> DistMap;
+    typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a DistMap.
 
@@ -1034 +1036 @@
   /// The \ref DijkstraWizardBase is a class to be the default traits of the
   /// \ref DijkstraWizard class.
-  template<class GR,class LM>
-  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LM>
+  template<typename GR, typename LEN>
+  class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
   {
-    typedef DijkstraWizardDefaultTraits<GR,LM> Base;
+    typedef DijkstraWizardDefaultTraits<GR,LEN> Base;
   protected:
     //The type of the nodes in the digraph.
@@ -1071 +1073 @@
     /// \param g The digraph the algorithm runs on.
     /// \param l The length map.
-    DijkstraWizardBase(const GR &g,const LM &l) :
+    DijkstraWizardBase(const GR &g,const LEN &l) :
       _g(reinterpret_cast<void*>(const_cast<GR*>(&g))),
-      _length(reinterpret_cast<void*>(const_cast<LM*>(&l))),
+      _length(reinterpret_cast<void*>(const_cast<LEN*>(&l))),
       _processed(0), _pred(0), _dist(0), _path(0), _di(0) {}
 
@@ -1282 +1284 @@
   ///\sa DijkstraWizard
   ///\sa Dijkstra
-  template<class GR, class LM>
-  DijkstraWizard<DijkstraWizardBase<GR,LM> >
-  dijkstra(const GR &digraph, const LM &length)
+  template<typename GR, typename LEN>
+  DijkstraWizard<DijkstraWizardBase<GR,LEN> >
+  dijkstra(const GR &digraph, const LEN &length)
   {
-    return DijkstraWizard<DijkstraWizardBase<GR,LM> >(digraph,length);
+    return DijkstraWizard<DijkstraWizardBase<GR,LEN> >(digraph,length);
   }
 

lemon/edge_set.h

@@ -256 +256 @@
   /// concept.
   ///
-  /// This class is fully conform to the \ref concepts::Digraph
+  /// This class fully conforms 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 is fully conform to the \ref concepts::Graph "Graph"
+  /// This class fully conforms 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 is fully conform to the \ref concepts::Digraph
+  /// This class fully conforms 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 is fully conform to the \ref concepts::Graph
+  /// This class fully conforms 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 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>
+  ///\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>
   class Elevator
   {
@@ -61 +61 @@
 
     typedef Item *Vit;
-    typedef typename ItemSetTraits<Graph,Item>::template Map<Vit>::Type VitMap;
-    typedef typename ItemSetTraits<Graph,Item>::template Map<int>::Type IntMap;
-
-    const Graph &_g;
+    typedef typename ItemSetTraits<GR,Item>::template Map<Vit>::Type VitMap;
+    typedef typename ItemSetTraits<GR,Item>::template Map<int>::Type IntMap;
+
+    const GR &_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 Graph &graph,int max_level) :
+    Elevator(const GR &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 Graph &graph) :
+    Elevator(const GR &graph) :
       _g(graph),
-      _max_level(countItems<Graph, Item>(graph)),
+      _max_level(countItems<GR, Item>(graph)),
       _item_num(_max_level),
       _where(graph),
@@ -431 +431 @@
       _last_active[0]=&_items[0]-1;
       Vit n=&_items[0];
-      for(typename ItemSetTraits<Graph,Item>::ItemIt i(_g);i!=INVALID;++i)
+      for(typename ItemSetTraits<GR,Item>::ItemIt i(_g);i!=INVALID;++i)
         {
           *n=i;
@@ -490 +490 @@
   ///\sa Elevator
   ///
-  ///\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>
+  ///\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>
   class LinkedElevator {
   public:
@@ -502 +502 @@
   private:
 
-    typedef typename ItemSetTraits<Graph,Item>::
+    typedef typename ItemSetTraits<GR,Item>::
     template Map<Item>::Type ItemMap;
-    typedef typename ItemSetTraits<Graph,Item>::
+    typedef typename ItemSetTraits<GR,Item>::
     template Map<int>::Type IntMap;
-    typedef typename ItemSetTraits<Graph,Item>::
+    typedef typename ItemSetTraits<GR,Item>::
     template Map<bool>::Type BoolMap;
 
-    const Graph &_graph;
+    const GR &_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 Graph& graph, int max_level)
+    LinkedElevator(const GR& 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 Graph& graph)
-      : _graph(graph), _max_level(countItems<Graph, Item>(graph)),
+    LinkedElevator(const GR& graph)
+      : _graph(graph), _max_level(countItems<GR, Item>(graph)),
         _item_num(_max_level),
         _first(_max_level + 1), _last(_max_level + 1),
@@ -936 +936 @@
       }
       _init_level = 0;
-      for(typename ItemSetTraits<Graph,Item>::ItemIt i(_graph);
+      for(typename ItemSetTraits<GR,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<class Digraph>
+  template<typename GR>
   class DiEulerIt
   {
-    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;
+    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;
     std::list<Arc> euler;
 
@@ -73 +73 @@
     ///Constructor
 
-    ///\param _g A digraph.
+    ///\param gr 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 Digraph &_g,typename Digraph::Node start=INVALID)
-      : g(_g), nedge(g)
+    DiEulerIt(const GR &gr, typename GR::Node start = INVALID)
+      : g(gr), 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<class Digraph>
+  template<typename GR>
   class EulerIt
   {
-    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;
+    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;
     std::list<Arc> euler;
 
@@ -166 +166 @@
     ///Constructor
 
-    ///\param _g An graph.
+    ///\param gr 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 Digraph &_g,typename Digraph::Node start=INVALID)
-      : g(_g), nedge(g), visited(g,false)
+    EulerIt(const GR &gr, typename GR::Node start = INVALID)
+      : g(gr), 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<class Digraph>
+  template<typename GR>
 #ifdef DOXYGEN
   bool
 #else
-  typename enable_if<UndirectedTagIndicator<Digraph>,bool>::type
-  eulerian(const Digraph &g)
-  {
-    for(typename Digraph::NodeIt n(g);n!=INVALID;++n)
+  typename enable_if<UndirectedTagIndicator<GR>,bool>::type
+  eulerian(const GR &g)
+  {
+    for(typename GR::NodeIt n(g);n!=INVALID;++n)
       if(countIncEdges(g,n)%2) return false;
     return connected(g);
   }
-  template<class Digraph>
-  typename disable_if<UndirectedTagIndicator<Digraph>,bool>::type
+  template<class GR>
+  typename disable_if<UndirectedTagIndicator<GR>,bool>::type
 #endif
-  eulerian(const Digraph &g)
-  {
-    for(typename Digraph::NodeIt n(g);n!=INVALID;++n)
+  eulerian(const GR &g)
+  {
+    for(typename GR::NodeIt n(g);n!=INVALID;++n)
       if(countInArcs(g,n)!=countOutArcs(g,n)) return false;
-    return connected(Undirector<const Digraph>(g));
+    return connected(Undirector<const GR>(g));
   }
 

lemon/graph_to_eps.h

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

lemon/grid_graph.h

@@ -497 +497 @@
   ///\endcode
   ///
-  /// This graph type is fully conform to the \ref concepts::Graph
+  /// This graph type fully conforms 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 _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>.
+  /// \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>".
 #ifdef DOXYGEN
-  template <typename _Digraph, typename _CapacityMap, typename _Tolerance>
+  template <typename GR, typename CAP, typename TOL>
 #else
-  template <typename _Digraph,
-            typename _CapacityMap = typename _Digraph::template ArcMap<int>,
-            typename _Tolerance = Tolerance<typename _CapacityMap::Value> >
+  template <typename GR,
+            typename CAP = typename GR::template ArcMap<int>,
+            typename TOL = Tolerance<typename CAP::Value> >
 #endif
   class HaoOrlin {
   private:
 
-    typedef _Digraph Digraph;
-    typedef _CapacityMap CapacityMap;
-    typedef _Tolerance Tolerance;
+    typedef GR Digraph;
+    typedef CAP CapacityMap;
+    typedef TOL 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 \c run(...).
+    /// one of the member functions called \ref 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 is fully conform to the \ref concepts::Graph
+  /// This graph type fully conforms 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 _Digraph>
+  template <typename GR>
   class DigraphReader {
   public:
 
-    typedef _Digraph Digraph;
+    typedef GR Digraph;
+
+  private:
+
     TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-  private:
-
 
     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 _Graph>
+  template <typename GR>
   class GraphReader {
   public:
 
-    typedef _Graph Graph;
+    typedef GR Graph;
+
+  private:
+
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-  private:
 
     std::istream* _is;
@@ -1357 +1358 @@
 
   private:
-    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);
+    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);
 
     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 _Digraph>
+  template <typename GR>
   class DigraphWriter {
   public:
 
-    typedef _Digraph Digraph;
+    typedef GR 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 _Graph>
+  template <typename GR>
   class GraphWriter {
   public:
 
-    typedef _Graph Graph;
+    typedef GR Graph;
     TEMPLATE_GRAPH_TYPEDEFS(Graph);
 
@@ -1074 +1074 @@
   private:
 
-    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);
+    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);
     
     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:
-    typedef MapBase<K, V> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
 
     /// Gives back a default constructed element.
@@ -103 +104 @@
     V _value;
   public:
-    typedef MapBase<K, V> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
 
     /// Default constructor
@@ -169 +171 @@
   class ConstMap<K, Const<V, v> > : public MapBase<K, V> {
   public:
-    typedef MapBase<K, V> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
 
     /// Constructor.
@@ -203 +206 @@
   class IdentityMap : public MapBase<T, T> {
   public:
-    typedef MapBase<T, T> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef T Key;
+    ///\e
+    typedef T Value;
 
     /// Gives back the given value without any modification.
@@ -246 +250 @@
   public:
 
-    typedef MapBase<int, V> Parent;
     /// Key type
-    typedef typename Parent::Key Key;
+    typedef int Key;
     /// Value type
-    typedef typename Parent::Value Value;
+    typedef V Value;
     /// Reference type
     typedef typename Vector::reference Reference;
@@ -354 +357 @@
   /// The simplest way of using this map is through the sparseMap()
   /// function.
-  template <typename K, typename V, typename Compare = std::less<K> >
+  template <typename K, typename V, typename Comp = std::less<K> >
   class SparseMap : public MapBase<K, V> {
     template <typename K1, typename V1, typename C1>
@@ -360 +363 @@
   public:
 
-    typedef MapBase<K, V> Parent;
     /// Key type
-    typedef typename Parent::Key Key;
+    typedef K Key;
     /// Value type
-    typedef typename Parent::Value Value;
+    typedef V Value;
     /// Reference type
     typedef Value& Reference;
@@ -374 +376 @@
   private:
 
-    typedef std::map<K, V, Compare> Map;
+    typedef std::map<K, V, Comp> Map;
     Map _map;
     Value _value;
@@ -490 +492 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M2::Key, typename M1::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M2::Key Key;
+    ///\e
+    typedef typename M1::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]]; }
@@ -546 +549 @@
     F _f;
   public:
-    typedef MapBase<typename M1::Key, V> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef V 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]); }
   };
@@ -616 +620 @@
     F _f;
   public:
-    typedef MapBase<K, V> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef V Value;
 
     /// Constructor
     FunctorToMap(const F &f = F()) : _f(f) {}
-    /// \e
+    ///\e
     Value operator[](const Key &k) const { return _f(k); }
   };
@@ -670 +675 @@
     const M &_m;
   public:
-    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;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
+
+    typedef typename M::Key argument_type;
+    typedef typename M::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]; }
   };
@@ -710 +716 @@
     const M &_m;
   public:
-    typedef MapBase<typename M::Key, V> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef V Value;
 
     /// Constructor
@@ -720 +727 @@
     ConvertMap(const M &m) : _m(m) {}
 
-    /// \e
+    ///\e
     Value operator[](const Key &k) const { return _m[k]; }
   };
@@ -752 +759 @@
     M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::Value Value;
 
     /// Constructor
@@ -798 +806 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::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]; }
   };
@@ -846 +855 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::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]; }
   };
@@ -895 +905 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::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]; }
   };
@@ -943 +954 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, typename M1::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef typename M1::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]; }
   };
@@ -993 +1005 @@
     C _v;
   public:
-    typedef MapBase<typename M::Key, typename M::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
 
     /// Constructor
@@ -1003 +1016 @@
     /// \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; }
   };
@@ -1023 +1036 @@
     C _v;
   public:
-    typedef MapBase<typename M::Key, typename M::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
 
     /// Constructor
@@ -1033 +1047 @@
     /// \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); }
   };
@@ -1094 +1108 @@
     C _v;
   public:
-    typedef MapBase<typename M::Key, typename M::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
 
     /// Constructor
@@ -1104 +1119 @@
     /// \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]; }
   };
@@ -1125 +1140 @@
     C _v;
   public:
-    typedef MapBase<typename M::Key, typename M::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
 
     /// Constructor
@@ -1135 +1151 @@
     /// \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); }
   };
@@ -1194 +1210 @@
     const M& _m;
   public:
-    typedef MapBase<typename M::Key, typename M::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
 
     /// Constructor
     NegMap(const M &m) : _m(m) {}
-    /// \e
+    ///\e
     Value operator[](const Key &k) const { return -_m[k]; }
   };
@@ -1229 +1246 @@
     M &_m;
   public:
-    typedef MapBase<typename M::Key, typename M::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::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); }
   };
@@ -1283 +1301 @@
     const M &_m;
   public:
-    typedef MapBase<typename M::Key, typename M::Value> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef typename M::Value Value;
 
     /// Constructor
     AbsMap(const M &m) : _m(m) {}
-    /// \e
+    ///\e
     Value operator[](const Key &k) const {
       Value tmp = _m[k];
@@ -1338 +1357 @@
   class TrueMap : public MapBase<K, bool> {
   public:
-    typedef MapBase<K, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef bool Value;
 
     /// Gives back \c true.
@@ -1375 +1395 @@
   class FalseMap : public MapBase<K, bool> {
   public:
-    typedef MapBase<K, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef K Key;
+    ///\e
+    typedef bool Value;
 
     /// Gives back \c false.
@@ -1420 +1441 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool 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]; }
   };
@@ -1468 +1490 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool 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]; }
   };
@@ -1507 +1530 @@
     const M &_m;
   public:
-    typedef MapBase<typename M::Key, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef bool Value;
 
     /// Constructor
     NotMap(const M &m) : _m(m) {}
-    /// \e
+    ///\e
     Value operator[](const Key &k) const { return !_m[k]; }
   };
@@ -1533 +1557 @@
     M &_m;
   public:
-    typedef MapBase<typename M::Key, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M::Key Key;
+    ///\e
+    typedef bool 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); }
   };
@@ -1596 +1621 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool 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]; }
   };
@@ -1644 +1670 @@
     const M2 &_m2;
   public:
-    typedef MapBase<typename M1::Key, bool> Parent;
-    typedef typename Parent::Key Key;
-    typedef typename Parent::Value Value;
+    ///\e
+    typedef typename M1::Key Key;
+    ///\e
+    typedef bool 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]; }
   };
@@ -1706 +1733 @@
   /// function.
   ///
-  /// \tparam It The type of the iterator.
-  /// \tparam Ke The key type of the map. The default value set
+  /// \tparam IT The type of the iterator.
+  /// \tparam KEY The key type of the map. The default value set
   /// according to the iterator type should work in most cases.
   ///
@@ -1713 +1740 @@
   /// for the elements or the iterator should be an inserter iterator.
 #ifdef DOXYGEN
-  template <typename It, typename Ke>
+  template <typename IT, typename KEY>
 #else
-  template <typename It,
-            typename Ke=typename _maps_bits::IteratorTraits<It>::Value>
+  template <typename IT,
+            typename KEY = typename _maps_bits::IteratorTraits<IT>::Value>
 #endif
-  class LoggerBoolMap {
-  public:
-    typedef It Iterator;
-
-    typedef Ke Key;
+  class LoggerBoolMap : public MapBase<KEY, bool> {
+  public:
+
+    ///\e
+    typedef KEY Key;
+    ///\e
     typedef bool Value;
+    ///\e
+    typedef IT Iterator;
 
     /// Constructor
@@ -1786 +1816 @@
   /// @{
 
-  /// 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
+  /// \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
   /// class \c InverseMap or with the \c operator() member.
   ///
-  template <typename _Graph, typename _Item>
-  class IdMap {
-  public:
-    typedef _Graph Graph;
+  /// \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.
     typedef int Value;
-    typedef _Item Item;
-    typedef _Item Key;
 
     /// \brief Constructor.
@@ -1814 +1856 @@
     int operator[](const Item& item) const { return _graph->id(item);}
 
-    /// \brief Gives back the item by its id.
-    ///
-    /// Gives back the item by its id.
+    /// \brief Gives back the \e item by its id.
+    ///
+    /// Gives back the \e item by its id.
     Item operator()(int id) { return _graph->fromId(id, Item()); }
 
@@ -1824 +1866 @@
   public:
 
-    /// \brief The class represents the inverse of its owner (IdMap).
-    ///
-    /// The class represents the inverse of its owner (IdMap).
+    /// \brief This class represents the inverse of its owner (IdMap).
+    ///
+    /// This class represents the inverse of its owner (IdMap).
     /// \see inverse()
     class InverseMap {
@@ -1844 +1886 @@
       ///
       /// Gives back the given item from its id.
-      ///
       Item operator[](int id) const { return _graph->fromId(id, Item());}
 
@@ -1855 +1896 @@
     /// Gives back the inverse of the IdMap.
     InverseMap inverse() const { return InverseMap(*_graph);}
-
-  };
-
-
-  /// \brief General invertable graph-map type.
-
-  /// This type provides simple invertable graph-maps.
-  /// The InvertableMap wraps an arbitrary ReadWriteMap
+  };
+
+
+  /// \brief General invertable graph map type.
+
+  /// This class provides simple invertable graph maps.
+  /// It wraps an arbitrary \ref concepts::ReadWriteMap "ReadWriteMap"
   /// and if a key is set to a new value then store it
   /// in the inverse map.
@@ -1869 +1909 @@
   /// with stl compatible forward iterator.
   ///
-  /// \tparam _Graph The graph type.
-  /// \tparam _Item The item type of the graph.
-  /// \tparam _Value The value type of the map.
+  /// \tparam GR The graph type.
+  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
+  /// \c GR::Edge).
+  /// \tparam V The value type of the map.
   ///
   /// \see IterableValueMap
-  template <typename _Graph, typename _Item, typename _Value>
+  template <typename GR, typename K, typename V>
   class InvertableMap
-    : protected ItemSetTraits<_Graph, _Item>::template Map<_Value>::Type {
+    : protected ItemSetTraits<GR, K>::template Map<V>::Type {
   private:
 
-    typedef typename ItemSetTraits<_Graph, _Item>::
-    template Map<_Value>::Type Map;
-    typedef _Graph Graph;
-
-    typedef std::map<_Value, _Item> Container;
+    typedef typename ItemSetTraits<GR, K>::
+      template Map<V>::Type Map;
+
+    typedef std::map<V, K> Container;
     Container _inv_map;
 
   public:
 
-    /// The key type of InvertableMap (Node, Arc, Edge).
-    typedef typename Map::Key Key;
-    /// The value type of the InvertableMap.
-    typedef typename Map::Value Value;
+    /// 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;
 
     /// \brief Constructor.
     ///
-    /// Construct a new InvertableMap for the graph.
-    ///
+    /// Construct a new InvertableMap for the given graph.
     explicit InvertableMap(const Graph& graph) : Map(graph) {}
 
@@ -1903 +1946 @@
     /// This iterator is an stl compatible forward
     /// iterator on the values of the map. The values can
-    /// be accessed in the [beginValue, endValue) range.
-    ///
+    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
     class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
@@ -1936 +1978 @@
     /// Returns an stl compatible iterator to the
     /// first value of the map. The values of the
-    /// map can be accessed in the [beginValue, endValue)
+    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
     ValueIterator beginValue() const {
@@ -1946 +1988 @@
     /// Returns an stl compatible iterator after the
     /// last value of the map. The values of the
-    /// map can be accessed in the [beginValue, endValue)
+    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
     ValueIterator endValue() const {
@@ -1952 +1994 @@
     }
 
-    /// \brief The setter function of the map.
-    ///
-    /// Sets the mapped value.
+    /// \brief Sets the value associated with the given key.
+    ///
+    /// Sets the value associated with the given key.
     void set(const Key& key, const Value& val) {
       Value oldval = Map::operator[](key);
@@ -1965 +2007 @@
     }
 
-    /// \brief The getter function of the map.
-    ///
-    /// It gives back the value associated with the key.
+    /// \brief Returns the value associated with the given key.
+    ///
+    /// Returns the value associated with the given key.
     typename MapTraits<Map>::ConstReturnValue
     operator[](const Key& key) const {
@@ -1983 +2025 @@
   protected:
 
-    /// \brief Erase the key from the map.
-    ///
-    /// Erase the key to the map. It is called by the
+    /// \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
     /// \c AlterationNotifier.
     virtual void erase(const Key& key) {
@@ -1996 +2038 @@
     }
 
-    /// \brief Erase more keys from the map.
-    ///
-    /// Erase more keys from the map. It is called by the
+    /// \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
     /// \c AlterationNotifier.
     virtual void erase(const std::vector<Key>& keys) {
@@ -2011 +2053 @@
     }
 
-    /// \brief Clear the keys from the map and inverse map.
-    ///
-    /// Clear the keys from the map and inverse map. It is called by the
+    /// \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
     /// \c AlterationNotifier.
     virtual void clear() {
@@ -2025 +2067 @@
     ///
     /// The inverse of this map. The subscript operator of the map
-    /// gives back always the item what was last assigned to the value.
+    /// gives back the item that was last assigned to the value.
     class InverseMap {
     public:
-      /// \brief Constructor of the InverseMap.
+      /// \brief Constructor
       ///
       /// Constructor of the InverseMap.
@@ -2041 +2083 @@
       /// \brief Subscript operator.
       ///
-      /// Subscript operator. It gives back always the item
-      /// what was last assigned to the value.
+      /// Subscript operator. It gives back the item
+      /// that was last assigned to the given value.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2051 +2093 @@
     };
 
-    /// \brief It gives back the just readable inverse map.
-    ///
-    /// It gives back the just readable inverse map.
+    /// \brief It gives back the read-only inverse map.
+    ///
+    /// It gives back the read-only inverse map.
     InverseMap inverse() const {
       return InverseMap(*this);
@@ -2061 +2103 @@
 
   /// \brief Provides a mutable, continuous and unique descriptor for each
-  /// 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>
+  /// 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>
   class DescriptorMap
-    : 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;
+    : 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;
     /// The value type of DescriptorMap.
-    typedef typename Map::Value Value;
+    typedef int Value;
 
     /// \brief Constructor.
     ///
     /// Constructor for descriptor map.
-    explicit DescriptorMap(const Graph& _graph) : Map(_graph) {
+    explicit DescriptorMap(const Graph& gr) : Map(gr) {
       Item it;
       const typename Map::Notifier* nf = Map::notifier();
@@ -2105 +2155 @@
   protected:
 
-    /// \brief Add a new key to the map.
+    /// \brief Adds a new key to the map.
     ///
     /// Add a new key to the map. It is called by the
@@ -2215 +2265 @@
 
   public:
+
     /// \brief The inverse map type of DescriptorMap.
     ///
@@ -2220 +2271 @@
     class InverseMap {
     public:
-      /// \brief Constructor of the InverseMap.
+      /// \brief Constructor
       ///
       /// Constructor of the InverseMap.
@@ -2235 +2286 @@
       ///
       /// Subscript operator. It gives back the item
-      /// that the descriptor belongs to currently.
+      /// that the descriptor currently belongs to.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2259 +2310 @@
   };
 
-  /// \brief Returns the source of the given arc.
-  ///
-  /// The SourceMap gives back the source Node of the given arc.
+  /// \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.
   /// \see TargetMap
-  template <typename Digraph>
+  template <typename GR>
   class SourceMap {
   public:
 
-    typedef typename Digraph::Node Value;
-    typedef typename Digraph::Arc Key;
+    ///\e
+    typedef typename GR::Arc Key;
+    ///\e
+    typedef typename GR::Node Value;
 
     /// \brief Constructor
     ///
-    /// Constructor
+    /// Constructor.
     /// \param digraph The digraph that the map belongs to.
-    explicit SourceMap(const Digraph& digraph) : _digraph(digraph) {}
-
-    /// \brief The subscript operator.
-    ///
-    /// The subscript operator.
-    /// \param arc The arc
-    /// \return The source of the arc
+    explicit SourceMap(const GR& digraph) : _graph(digraph) {}
+
+    /// \brief Returns the source node of the given arc.
+    ///
+    /// Returns the source node of the given arc.
     Value operator[](const Key& arc) const {
-      return _digraph.source(arc);
+      return _graph.source(arc);
     }
 
   private:
-    const Digraph& _digraph;
+    const GR& _graph;
   };
 
@@ -2293 +2346 @@
   /// This function just returns an \c SourceMap class.
   /// \relates SourceMap
-  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.
+  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.
   /// \see SourceMap
-  template <typename Digraph>
+  template <typename GR>
   class TargetMap {
   public:
 
-    typedef typename Digraph::Node Value;
-    typedef typename Digraph::Arc Key;
+    ///\e
+    typedef typename GR::Arc Key;
+    ///\e
+    typedef typename GR::Node Value;
 
     /// \brief Constructor
     ///
-    /// Constructor
+    /// Constructor.
     /// \param digraph The digraph that the map belongs to.
-    explicit TargetMap(const Digraph& digraph) : _digraph(digraph) {}
-
-    /// \brief The subscript operator.
-    ///
-    /// The subscript operator.
-    /// \param e The arc
-    /// \return The target of the arc
+    explicit TargetMap(const GR& digraph) : _graph(digraph) {}
+
+    /// \brief Returns the target node of the given arc.
+    ///
+    /// Returns the target node of the given arc.
     Value operator[](const Key& e) const {
-      return _digraph.target(e);
+      return _graph.target(e);
     }
 
   private:
-    const Digraph& _digraph;
+    const GR& _graph;
   };
 
@@ -2332 +2387 @@
   /// This function just returns a \c TargetMap class.
   /// \relates TargetMap
-  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.
+  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.
   /// \see BackwardMap
-  template <typename Graph>
+  template <typename GR>
   class ForwardMap {
   public:
 
-    typedef typename Graph::Arc Value;
-    typedef typename Graph::Edge Key;
+    typedef typename GR::Arc Value;
+    typedef typename GR::Edge Key;
 
     /// \brief Constructor
     ///
-    /// Constructor
+    /// Constructor.
     /// \param graph The graph that the map belongs to.
-    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
+    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.
     Value operator[](const Key& key) const {
       return _graph.direct(key, true);
@@ -2364 +2420 @@
 
   private:
-    const Graph& _graph;
+    const GR& _graph;
   };
 
@@ -2371 +2427 @@
   /// This function just returns an \c ForwardMap class.
   /// \relates ForwardMap
-  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.
+  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.
   /// \see ForwardMap
-  template <typename Graph>
+  template <typename GR>
   class BackwardMap {
   public:
 
-    typedef typename Graph::Arc Value;
-    typedef typename Graph::Edge Key;
+    typedef typename GR::Arc Value;
+    typedef typename GR::Edge Key;
 
     /// \brief Constructor
     ///
-    /// Constructor
+    /// Constructor.
     /// \param graph The graph that the map belongs to.
-    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
+    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.
     Value operator[](const Key& key) const {
       return _graph.direct(key, false);
@@ -2403 +2460 @@
 
   private:
-    const Graph& _graph;
+    const GR& _graph;
   };
 
@@ -2410 +2467 @@
   /// This function just returns a \c BackwardMap class.
   /// \relates BackwardMap
-  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.
+  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.
   ///
   /// This map returns the in-degree of a node. Once it is constructed,
-  /// the degrees are stored in a standard NodeMap, so each query is done
+  /// the degrees are stored in a standard \c NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
-  /// \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()",
+  /// \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()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
@@ -2472 +2489 @@
   ///
   /// \sa OutDegMap
-
-  template <typename _Digraph>
+  template <typename GR>
   class InDegMap
-    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
+    : protected ItemSetTraits<GR, typename GR::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
-
-    typedef _Digraph Digraph;
+    
+    /// The digraph type
+    typedef GR Digraph;
+    /// The key type
+    typedef typename Digraph::Node Key;
+    /// The value type
     typedef int Value;
-    typedef typename Digraph::Node Key;
 
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
@@ -2524 +2543 @@
     /// \brief Constructor.
     ///
-    /// Constructor for creating in-degree map.
-    explicit InDegMap(const Digraph& digraph)
-      : _digraph(digraph), _deg(digraph) {
+    /// Constructor for creating an in-degree map.
+    explicit InDegMap(const Digraph& graph)
+      : _digraph(graph), _deg(graph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 
@@ -2534 +2553 @@
     }
 
+    /// \brief Gives back the in-degree of a Node.
+    ///
     /// Gives back the in-degree of a Node.
     int operator[](const Key& key) const {
@@ -2580 +2601 @@
   };
 
-  /// \brief Map of the node out-degrees.
+  /// \brief Map of the out-degrees of nodes in a digraph.
   ///
   /// This map returns the out-degree of a node. Once it is constructed,
-  /// the degrees are stored in a standard NodeMap, so each query is done
+  /// the degrees are stored in a standard \c NodeMap, so each query is done
   /// in constant time. On the other hand, the values are updated automatically
   /// whenever the digraph changes.
   ///
-  /// \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()",
+  /// \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()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
   /// \ref ListDigraph::reverseArc() "reverseArc()"
@@ -2596 +2618 @@
   ///
   /// \sa InDegMap
-
-  template <typename _Digraph>
+  template <typename GR>
   class OutDegMap
-    : protected ItemSetTraits<_Digraph, typename _Digraph::Arc>
+    : protected ItemSetTraits<GR, typename GR::Arc>
       ::ItemNotifier::ObserverBase {
 
   public:
 
-    typedef _Digraph Digraph;
+    /// The digraph type
+    typedef GR Digraph;
+    /// The key type
+    typedef typename Digraph::Node Key;
+    /// The value type
     typedef int Value;
-    typedef typename Digraph::Node Key;
 
     typedef typename ItemSetTraits<Digraph, typename Digraph::Arc>
@@ -2646 +2670 @@
     /// \brief Constructor.
     ///
-    /// Constructor for creating out-degree map.
-    explicit OutDegMap(const Digraph& digraph)
-      : _digraph(digraph), _deg(digraph) {
+    /// Constructor for creating an out-degree map.
+    explicit OutDegMap(const Digraph& graph)
+      : _digraph(graph), _deg(graph) {
       Parent::attach(_digraph.notifier(typename Digraph::Arc()));
 
@@ -2656 +2680 @@
     }
 
+    /// \brief Gives back the out-degree of a Node.
+    ///
     /// Gives back the out-degree of a Node.
     int operator[](const Key& key) const {
@@ -2702 +2728 @@
   };
 
+  /// \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 _Graph The graph type the algorithm runs on.
-  template <typename _Graph>
+  /// \param GR The graph type the algorithm runs on.
+  template <typename GR>
   class MaxMatching {
   public:
 
-    typedef _Graph Graph;
+    typedef GR 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 %True if the map contains a matching.
+    /// \return \c 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 _Graph,
-            typename _WeightMap = typename _Graph::template EdgeMap<int> >
+  template <typename GR,
+            typename WM = typename GR::template EdgeMap<int> >
   class MaxWeightedMatching {
   public:
 
-    typedef _Graph Graph;
-    typedef _WeightMap WeightMap;
+    ///\e
+    typedef GR Graph;
+    ///\e
+    typedef WM WeightMap;
+    ///\e
     typedef typename WeightMap::Value Value;
 
@@ -1958 +1961 @@
   /// 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
@@ -1991 +1994 @@
   /// of a blossom. If the value type is integral then the dual
   /// solution is multiplied by \ref MaxWeightedMatching::dualScale "4".
-  template <typename _Graph,
-            typename _WeightMap = typename _Graph::template EdgeMap<int> >
+  template <typename GR,
+            typename WM = typename GR::template EdgeMap<int> >
   class MaxWeightedPerfectMatching {
   public:
 
-    typedef _Graph Graph;
-    typedef _WeightMap WeightMap;
+    typedef GR Graph;
+    typedef WM WeightMap;
     typedef typename WeightMap::Value Value;
 

lemon/min_cost_arborescence.h

@@ -36 +36 @@
   ///
   /// Default traits class for MinCostArborescence class.
-  /// \param _Digraph Digraph type.
-  /// \param _CostMap Type of cost map.
-  template <class _Digraph, class _CostMap>
+  /// \param GR Digraph type.
+  /// \param CM Type of cost map.
+  template <class GR, class CM>
   struct MinCostArborescenceDefaultTraits{
 
     /// \brief The digraph type the algorithm runs on.
-    typedef _Digraph Digraph;
+    typedef GR 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 _CostMap CostMap;
+    typedef CM CostMap;
 
     /// \brief The value type of the costs.
@@ -64 +64 @@
     typedef typename Digraph::template ArcMap<bool> ArborescenceMap;
 
-    /// \brief Instantiates a ArborescenceMap.
-    ///
-    /// This function instantiates a \ref ArborescenceMap.
+    /// \brief Instantiates a \c ArborescenceMap.
+    ///
+    /// This function instantiates a \c ArborescenceMap.
     /// \param digraph is the graph, to which we would like to
-    /// calculate the ArborescenceMap.
+    /// calculate the \c ArborescenceMap.
     static ArborescenceMap *createArborescenceMap(const Digraph &digraph){
       return new ArborescenceMap(digraph);
     }
 
-    /// \brief The type of the PredMap
-    ///
-    /// The type of the PredMap. It is a node map with an arc value type.
+    /// \brief The type of the \c PredMap
+    ///
+    /// The type of the \c PredMap. It is a node map with an arc value type.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> 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.
+    /// \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.
     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 \f$ O(n^2+e) \f$.
+  /// sources. The time complexity of the algorithm is O(n<sup>2</sup>+e).
   ///
   /// The algorithm provides also an optimal dual solution, therefore
   /// the optimality of the solution can be checked.
   ///
-  /// \param _Digraph The digraph type the algorithm runs on. The default value
+  /// \param GR The digraph type the algorithm runs on. The default value
   /// is \ref ListDigraph.
-  /// \param _CostMap This read-only ArcMap determines the costs of the
+  /// \param CM 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 _Traits Traits class to set various data types used
+  /// \param TR Traits class to set various data types used
   /// by the algorithm. The default traits class is
   /// \ref MinCostArborescenceDefaultTraits
-  /// "MinCostArborescenceDefaultTraits<_Digraph, _CostMap>".  See \ref
+  /// "MinCostArborescenceDefaultTraits<GR, CM>".  See \ref
   /// MinCostArborescenceDefaultTraits for the documentation of a
   /// MinCostArborescence traits class.
-  ///
-  /// \author Balazs Dezso
 #ifndef DOXYGEN
-  template <typename _Digraph = ListDigraph,
-            typename _CostMap = typename _Digraph::template ArcMap<int>,
-            typename _Traits =
-            MinCostArborescenceDefaultTraits<_Digraph, _CostMap> >
+  template <typename GR = ListDigraph,
+            typename CM = typename GR::template ArcMap<int>,
+            typename TR =
+              MinCostArborescenceDefaultTraits<GR, CM> >
 #else
-  template <typename _Digraph, typename _CostMap, typedef _Traits>
+  template <typename GR, typename CM, typedef TR>
 #endif
   class MinCostArborescence {
@@ -131 +129 @@
 
     /// The traits.
-    typedef _Traits Traits;
+    typedef TR Traits;
     /// The type of the underlying digraph.
     typedef typename Traits::Digraph Digraph;
@@ -441 +439 @@
     /// \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),
@@ -457 +455 @@
     ///
     /// Sets the arborescence map.
-    /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     MinCostArborescence& arborescenceMap(ArborescenceMap& m) {
       if (local_arborescence) {
@@ -470 +468 @@
     ///
     /// Sets the arborescence map.
-    /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     MinCostArborescence& predMap(PredMap& m) {
       if (local_pred) {

lemon/path.h

@@ -41 +41 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR 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 _Digraph>
+  template <typename GR>
   class Path {
   public:
 
-    typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -138 +138 @@
     /// \brief The nth arc.
     ///
-    /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> 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 n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -229 +229 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR 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 _Digraph>
+  template <typename GR>
   class SimplePath {
   public:
 
-    typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -330 +330 @@
     /// \brief The nth arc.
     ///
-    /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
       return data[n];
@@ -393 +393 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR 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 _Digraph>
+  template <typename GR>
   class ListPath {
   public:
 
-    typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -508 +508 @@
     ///
     /// This function looks for the nth arc in O(n) time.
-    /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
       Node *node = first;
@@ -733 +733 @@
   ///
   /// A structure for representing directed path in a digraph.
-  /// \tparam _Digraph The digraph type in which the path is.
+  /// \tparam GR 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 _Digraph>
+  template <typename GR>
   class StaticPath {
   public:
 
-    typedef _Digraph Digraph;
+    typedef GR Digraph;
     typedef typename Digraph::Arc Arc;
 
@@ -834 +834 @@
     /// \brief The nth arc.
     ///
-    /// \pre n is in the [0..length() - 1] range
+    /// \pre \c n is in the <tt>[0..length() - 1]</tt> 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 CM Capacity map type.
-  template <typename GR, typename CM>
+  /// \tparam CAP Capacity map type.
+  template <typename GR, typename CAP>
   struct PreflowDefaultTraits {
 
@@ -44 +44 @@
     /// The type of the map that stores the arc capacities.
     /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CM CapacityMap;
+    typedef CAP 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 flow of maximum value in a
-  /// digraph. The preflow algorithms are the fastest known maximum
+  /// \e push-relabel algorithm producing a \ref max_flow
+  /// "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.
@@ -106 +107 @@
   ///
   /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the capacity map. The default map
+  /// \tparam CAP The type of the capacity map. The default map
   /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
 #ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
+  template <typename GR, typename CAP, typename TR>
 #else
   template <typename GR,
-            typename CM = typename GR::template ArcMap<int>,
-            typename TR = PreflowDefaultTraits<GR, CM> >
+            typename CAP = typename GR::template ArcMap<int>,
+            typename TR = PreflowDefaultTraits<GR, CAP> >
 #endif
   class Preflow {
@@ -195 +196 @@
     ///@{
 
-    template <typename _FlowMap>
+    template <typename T>
     struct SetFlowMapTraits : public Traits {
-      typedef _FlowMap FlowMap;
+      typedef T FlowMap;
       static FlowMap *createFlowMap(const Digraph&) {
         LEMON_ASSERT(false, "FlowMap is not initialized");
@@ -209 +210 @@
     /// \ref named-templ-param "Named parameter" for setting FlowMap
     /// type.
-    template <typename _FlowMap>
+    template <typename T>
     struct SetFlowMap
-      : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<_FlowMap> > {
+      : public Preflow<Digraph, CapacityMap, SetFlowMapTraits<T> > {
       typedef Preflow<Digraph, CapacityMap,
-                      SetFlowMapTraits<_FlowMap> > Create;
+                      SetFlowMapTraits<T> > Create;
     };
 
-    template <typename _Elevator>
+    template <typename T>
     struct SetElevatorTraits : public Traits {
-      typedef _Elevator Elevator;
+      typedef T Elevator;
       static Elevator *createElevator(const Digraph&, int) {
         LEMON_ASSERT(false, "Elevator is not initialized");
@@ -234 +235 @@
     /// \ref run() or \ref init().
     /// \sa SetStandardElevator
-    template <typename _Elevator>
+    template <typename T>
     struct SetElevator
-      : public Preflow<Digraph, CapacityMap, SetElevatorTraits<_Elevator> > {
+      : public Preflow<Digraph, CapacityMap, SetElevatorTraits<T> > {
       typedef Preflow<Digraph, CapacityMap,
-                      SetElevatorTraits<_Elevator> > Create;
+                      SetElevatorTraits<T> > Create;
     };
 
-    template <typename _Elevator>
+    template <typename T>
     struct SetStandardElevatorTraits : public Traits {
-      typedef _Elevator Elevator;
+      typedef T Elevator;
       static Elevator *createElevator(const Digraph& digraph, int max_level) {
         return new Elevator(digraph, max_level);
@@ -261 +262 @@
     /// before calling \ref run() or \ref init().
     /// \sa SetElevator
-    template <typename _Elevator>
+    template <typename T>
     struct SetStandardElevator
       : public Preflow<Digraph, CapacityMap,
-                       SetStandardElevatorTraits<_Elevator> > {
+                       SetStandardElevatorTraits<T> > {
       typedef Preflow<Digraph, CapacityMap,
-                      SetStandardElevatorTraits<_Elevator> > Create;
+                      SetStandardElevatorTraits<T> > Create;
     };
 
@@ -947 +948 @@
     ///
     /// \note This function calls \ref minCut() for each node, so it runs in
-    /// \f$O(n)\f$ time.
+    /// O(n) 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 \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.
+  /// 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.
   ///
   /// \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 \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
+  /// 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
   /// 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 true.
+    /// \return Currently always \c true.
     bool seed() {
 #ifndef WIN32
@@ -625 +625 @@
     /// \param file The source file
     /// \param offset The offset, from the file read.
-    /// \return True when the seeding successes.
+    /// \return \c 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 true.
+    /// \return Currently always \c true.
     bool seedFromTime() {
 #ifndef WIN32

lemon/smart_graph.h

@@ -226 +226 @@
     ///Add a new node to the digraph.
 
-    /// \return the new node.
-    ///
+    /// Add a new node to the digraph.
+    /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 
@@ -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.
 
-    /// \return the new node.
-    ///
+    /// Add a new node to the graph.
+    /// \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 Digraph The digraph type the algorithm runs on.
+  /// \tparam GR The digraph type the algorithm runs on.
   /// The default value is \c ListDigraph.
-  /// \tparam LengthMap The type of the length (cost) map.
+  /// \tparam LEN 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 Digraph, typename LengthMap>
+  template <typename GR, typename LEN>
 #else
-  template < typename Digraph = ListDigraph,
-             typename LengthMap = typename Digraph::template ArcMap<int> >
+  template < typename GR = ListDigraph,
+             typename LEN = typename GR::template ArcMap<int> >
 #endif
   class Suurballe
   {
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
+    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
+
+    typedef ConstMap<Arc, int> ConstArcMap;
+    typedef typename GR::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;
-    typedef ConstMap<Arc, int> ConstArcMap;
-    typedef typename Digraph::template NodeMap<Arc> PredMap;
-
-  public:
-
     /// The type of the flow map.
     typedef typename Digraph::template ArcMap<int> FlowMap;
@@ -257 +262 @@
     /// the found arc-disjoint paths.
     ///
-    /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     Suurballe& flowMap(FlowMap &map) {
       if (_local_flow) {
@@ -274 +279 @@
     /// minimum cost flow problem.
     ///
-    /// \return \c (*this)
+    /// \return <tt>(*this)</tt>
     Suurballe& potentialMap(PotentialMap &map) {
       if (_local_potential) {
@@ -459 +464 @@
     ///
     /// This function returns the total length (cost) of the found paths
-    /// (flow). The complexity of the function is \f$ O(e) \f$.
+    /// (flow). The complexity of the function is O(e).
     ///
     /// \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 _ItemIntMap>
+  template <typename IM>
   class UnionFind {
   public:
 
-    typedef _ItemIntMap ItemIntMap;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
     typedef typename ItemIntMap::Key Item;
 
@@ -171 +173 @@
   /// method.
   ///
-  template <typename _ItemIntMap>
+  template <typename IM>
   class UnionFindEnum {
   public:
 
-    typedef _ItemIntMap ItemIntMap;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
     typedef typename ItemIntMap::Key Item;
 
@@ -628 +632 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  template <typename _ItemIntMap>
+  template <typename IM>
   class ExtendFindEnum {
   public:
 
-    typedef _ItemIntMap ItemIntMap;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
     typedef typename ItemIntMap::Key Item;
 
@@ -949 +955 @@
   /// \pre You need to add all the elements by the \ref insert()
   /// method.
-  ///
-  template <typename _Value, typename _ItemIntMap,
-            typename _Comp = std::less<_Value> >
+  template <typename V, typename IM, typename Comp = std::less<V> >
   class HeapUnionFind {
   public:
 
-    typedef _Value Value;
-    typedef typename _ItemIntMap::Key Item;
-
-    typedef _ItemIntMap ItemIntMap;
-
-    typedef _Comp Comp;
+    ///\e
+    typedef V Value;
+    ///\e
+    typedef typename IM::Key Item;
+    ///\e
+    typedef IM ItemIntMap;
+    ///\e
+    typedef Comp Compare;
 
   private:
@@ -1602 +1608 @@
     /// \brief Gives back the priority of the current item.
     ///
-    /// \return Gives back the priority of the current item.
+    /// Gives back the priority of the current item.
     const Value& operator[](const Item& item) const {
       return nodes[index[item]].prio;
@@ -1647 +1653 @@
     /// \brief Gives back the minimum priority of the class.
     ///
-    /// \return Gives back the minimum priority of the class.
+    /// Gives back the minimum priority of the class.
     const Value& classPrio(int cls) const {
       return nodes[~(classes[cls].parent)].prio;
@@ -1661 +1667 @@
     /// \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;