Index: lemon/binom_heap.h
===================================================================
--- lemon/binom_heap.h	(revision 748)
+++ lemon/binom_heap.h	(revision 750)
@@ -1,7 +1,7 @@
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -21,8 +21,9 @@
 
 ///\file
-///\ingroup auxdat
+///\ingroup heaps
 ///\brief Binomial Heap implementation.
 
 #include <vector>
+#include <utility>
 #include <functional>
 #include <lemon/math.h>
@@ -31,181 +32,186 @@
 namespace lemon {
 
-  /// \ingroup auxdat
+  /// \ingroup heaps
   ///
-  ///\brief Binomial Heap.
+  ///\brief Binomial heap data structure.
   ///
-  ///This class implements the \e Binomial \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 binomial \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
   ///
-  ///The methods \ref increase and \ref erase are not efficient in a Binomial
-  ///heap. In case of many calls to these operations, it is better to use a
-  ///\ref BinHeap "binary heap".
+  /// The methods \ref increase() and \ref erase() are not efficient
+  /// in a binomial heap. In case of many calls of these operations,
+  /// it is better to use other heap structure, e.g. \ref BinHeap
+  /// "binary heap".
   ///
-  ///\param _Prio Type of the priority of the items.
-  ///\param _ItemIntMap A read and writable Item int map, used internally
-  ///to handle the cross references.
-  ///\param _Compare A class for the ordering of the priorities. The
-  ///default is \c std::less<_Prio>.
-  ///
-  ///\sa BinHeap
-  ///\sa Dijkstra
-  ///\author Dorian Batha
-
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
 #ifdef DOXYGEN
-  template <typename _Prio,
-            typename _ItemIntMap,
-            typename _Compare>
+  template <typename PR, typename IM, typename CMP>
 #else
-  template <typename _Prio,
-            typename _ItemIntMap,
-            typename _Compare = std::less<_Prio> >
+  template <typename PR, typename IM, typename CMP = std::less<PR> >
 #endif
   class BinomHeap {
   public:
-    typedef _ItemIntMap ItemIntMap;
-    typedef _Prio Prio;
+    /// 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;
-    typedef std::pair<Item,Prio> Pair;
-    typedef _Compare Compare;
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// heap's point of view, but may be useful to the user.
+    ///
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    enum State {
+      IN_HEAP = 0,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
+    };
 
   private:
     class store;
 
-    std::vector<store> container;
-    int minimum, head;
-    ItemIntMap &iimap;
-    Compare comp;
-    int num_items;
+    std::vector<store> _data;
+    int _min, _head;
+    ItemIntMap &_iim;
+    Compare _comp;
+    int _num_items;
 
   public:
-    ///Status of the nodes
-    enum State {
-      ///The node is in the heap
-      IN_HEAP = 0,
-      ///The node has never been in the heap
-      PRE_HEAP = -1,
-      ///The node was in the heap but it got out of it
-      POST_HEAP = -2
-    };
-
-    /// \brief The constructor
-    ///
-    /// \c _iimap should be given to the constructor, since it is
-    ///   used internally to handle the cross references.
-    explicit BinomHeap(ItemIntMap &_iimap)
-      : minimum(0), head(-1), iimap(_iimap), num_items() {}
-
-    /// \brief The constructor
-    ///
-    /// \c _iimap should be given to the constructor, since it is used
-    /// internally to handle the cross references. \c _comp is an
-    /// object for ordering of the priorities.
-    BinomHeap(ItemIntMap &_iimap, const Compare &_comp)
-      : minimum(0), head(-1), iimap(_iimap), comp(_comp), num_items() {}
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit BinomHeap(ItemIntMap &map)
+      : _min(0), _head(-1), _iim(map), _num_items(0) {}
+
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    BinomHeap(ItemIntMap &map, const Compare &comp)
+      : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {}
 
     /// \brief The number of items stored in the heap.
     ///
-    /// Returns the number of items stored in the heap.
-    int size() const { return num_items; }
-
-    /// \brief Checks if the heap stores no items.
-    ///
-    ///   Returns \c true if and only if the heap stores no items.
-    bool empty() const { return num_items==0; }
-
-    /// \brief Make empty this heap.
-    ///
-    /// Make empty this heap. It does not change the cross reference
-    /// map.  If you want to reuse a heap what is not surely empty you
-    /// should first clear the heap and after that you should set the
-    /// cross reference map for each item to \c PRE_HEAP.
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _num_items; }
+
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _num_items==0; }
+
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
     void clear() {
-      container.clear(); minimum=0; num_items=0; head=-1;
-    }
-
-    /// \brief \c item gets to the heap with priority \c value independently
-    /// if \c item was already there.
-    ///
-    /// This method calls \ref push(\c item, \c value) if \c item is not
-    /// stored in the heap and it calls \ref decrease(\c item, \c value) or
-    /// \ref increase(\c item, \c value) otherwise.
+      _data.clear(); _min=0; _num_items=0; _head=-1;
+    }
+
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
+    /// \param item The item.
+    /// \param value The priority.
     void set (const Item& item, const Prio& value) {
-      int i=iimap[item];
-      if ( i >= 0 && container[i].in ) {
-        if ( comp(value, container[i].prio) ) decrease(item, value);
-        if ( comp(container[i].prio, value) ) increase(item, value);
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        if ( _comp(value, _data[i].prio) ) decrease(item, value);
+        if ( _comp(_data[i].prio, value) ) increase(item, value);
       } else push(item, value);
     }
 
-    /// \brief Adds \c item to the heap with priority \c value.
-    ///
-    /// Adds \c item to the heap with priority \c value.
-    /// \pre \c item must not be stored in the heap.
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
+    /// \param item The item to insert.
+    /// \param value The priority of the item.
+    /// \pre \e item must not be stored in the heap.
     void push (const Item& item, const Prio& value) {
-      int i=iimap[item];
+      int i=_iim[item];
       if ( i<0 ) {
-        int s=container.size();
-        iimap.set( item,s );
+        int s=_data.size();
+        _iim.set( item,s );
         store st;
         st.name=item;
-        container.push_back(st);
+        _data.push_back(st);
         i=s;
       }
       else {
-        container[i].parent=container[i].right_neighbor=container[i].child=-1;
-        container[i].degree=0;
-        container[i].in=true;
-      }
-      container[i].prio=value;
-
-      if( 0==num_items ) { head=i; minimum=i; }
+        _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
+        _data[i].degree=0;
+        _data[i].in=true;
+      }
+      _data[i].prio=value;
+
+      if( 0==_num_items ) { _head=i; _min=i; }
       else { merge(i); }
 
-      minimum = find_min();
-
-      ++num_items;
-    }
-
-    /// \brief Returns the item with minimum priority relative to \c Compare.
-    ///
-    /// This method returns the item with minimum priority relative to \c
-    /// Compare.
-    /// \pre The heap must be nonempty.
-    Item top() const { return container[minimum].name; }
-
-    /// \brief Returns the minimum priority relative to \c Compare.
-    ///
-    /// It returns the minimum priority relative to \c Compare.
-    /// \pre The heap must be nonempty.
-    const Prio& prio() const { return container[minimum].prio; }
-
-    /// \brief Returns the priority of \c item.
-    ///
-    /// It returns the priority of \c item.
-    /// \pre \c item must be in the heap.
+      _min = findMin();
+
+      ++_num_items;
+    }
+
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[_min].name; }
+
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    Prio prio() const { return _data[_min].prio; }
+
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param item The item.
+    /// \pre \e item must be in the heap.
     const Prio& operator[](const Item& item) const {
-      return container[iimap[item]].prio;
-    }
-
-    /// \brief Deletes the item with minimum priority relative to \c Compare.
-    ///
-    /// This method deletes the item with minimum priority relative to \c
-    /// Compare from the heap.
+      return _data[_iim[item]].prio;
+    }
+
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
-      container[minimum].in=false;
+      _data[_min].in=false;
 
       int head_child=-1;
-      if ( container[minimum].child!=-1 ) {
-        int child=container[minimum].child;
+      if ( _data[_min].child!=-1 ) {
+        int child=_data[_min].child;
         int neighb;
         int prev=-1;
         while( child!=-1 ) {
-          neighb=container[child].right_neighbor;
-          container[child].parent=-1;
-          container[child].right_neighbor=prev;
+          neighb=_data[child].right_neighbor;
+          _data[child].parent=-1;
+          _data[child].right_neighbor=prev;
           head_child=child;
           prev=child;
@@ -215,113 +221,115 @@
 
       // The first case is that there are only one root.
-      if ( -1==container[head].right_neighbor ) {
-        head=head_child;
+      if ( -1==_data[_head].right_neighbor ) {
+        _head=head_child;
       }
       // The case where there are more roots.
       else {
-        if( head!=minimum )  { unlace(minimum); }
-        else { head=container[head].right_neighbor; }
+        if( _head!=_min )  { unlace(_min); }
+        else { _head=_data[_head].right_neighbor; }
 
         merge(head_child);
       }
-      minimum=find_min();
-      --num_items;
-    }
-
-    /// \brief Deletes \c item from the heap.
-    ///
-    /// This method deletes \c item from the heap, if \c item was already
-    /// stored in the heap. It is quite inefficient in Binomial heaps.
+      _min=findMin();
+      --_num_items;
+    }
+
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param item The item to delete.
+    /// \pre \e item must be in the heap.
     void erase (const Item& item) {
-      int i=iimap[item];
-      if ( i >= 0 && container[i].in ) {
-        decrease( item, container[minimum].prio-1 );
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        decrease( item, _data[_min].prio-1 );
         pop();
       }
     }
 
-    /// \brief Decreases the priority of \c item to \c value.
-    ///
-    /// This method decreases the priority of \c item to \c value.
-    /// \pre \c item must be stored in the heap with priority at least \c
-    ///   value relative to \c Compare.
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at least \e value.
     void decrease (Item item, const Prio& value) {
-      int i=iimap[item];
-
-      if( comp( value,container[i].prio ) ) {
-        container[i].prio=value;
-
-        int p_loc=container[i].parent, loc=i;
+      int i=_iim[item];
+
+      if( _comp( value,_data[i].prio ) ) {
+        _data[i].prio=value;
+
+        int p_loc=_data[i].parent, loc=i;
         int parent, child, neighb;
 
-        while( -1!=p_loc && comp(container[loc].prio,container[p_loc].prio) ) {
+        while( -1!=p_loc && _comp(_data[loc].prio,_data[p_loc].prio) ) {
 
           // parent set for other loc_child
-          child=container[loc].child;
+          child=_data[loc].child;
           while( -1!=child ) {
-            container[child].parent=p_loc;
-            child=container[child].right_neighbor;
+            _data[child].parent=p_loc;
+            child=_data[child].right_neighbor;
           }
 
           // parent set for other p_loc_child
-          child=container[p_loc].child;
+          child=_data[p_loc].child;
           while( -1!=child ) {
-            container[child].parent=loc;
-            child=container[child].right_neighbor;
-          }
-
-          child=container[p_loc].child;
-          container[p_loc].child=container[loc].child;
+            _data[child].parent=loc;
+            child=_data[child].right_neighbor;
+          }
+
+          child=_data[p_loc].child;
+          _data[p_loc].child=_data[loc].child;
           if( child==loc )
             child=p_loc;
-          container[loc].child=child;
+          _data[loc].child=child;
 
           // left_neighb set for p_loc
-          if( container[loc].child!=p_loc ) {
-            while( container[child].right_neighbor!=loc )
-              child=container[child].right_neighbor;
-            container[child].right_neighbor=p_loc;
+          if( _data[loc].child!=p_loc ) {
+            while( _data[child].right_neighbor!=loc )
+              child=_data[child].right_neighbor;
+            _data[child].right_neighbor=p_loc;
           }
 
           // left_neighb set for loc
-          parent=container[p_loc].parent;
-          if( -1!=parent ) child=container[parent].child;
-          else child=head;
+          parent=_data[p_loc].parent;
+          if( -1!=parent ) child=_data[parent].child;
+          else child=_head;
 
           if( child!=p_loc ) {
-            while( container[child].right_neighbor!=p_loc )
-              child=container[child].right_neighbor;
-            container[child].right_neighbor=loc;
-          }
-
-          neighb=container[p_loc].right_neighbor;
-          container[p_loc].right_neighbor=container[loc].right_neighbor;
-          container[loc].right_neighbor=neighb;
-
-          container[p_loc].parent=loc;
-          container[loc].parent=parent;
-
-          if( -1!=parent && container[parent].child==p_loc )
-            container[parent].child=loc;
+            while( _data[child].right_neighbor!=p_loc )
+              child=_data[child].right_neighbor;
+            _data[child].right_neighbor=loc;
+          }
+
+          neighb=_data[p_loc].right_neighbor;
+          _data[p_loc].right_neighbor=_data[loc].right_neighbor;
+          _data[loc].right_neighbor=neighb;
+
+          _data[p_loc].parent=loc;
+          _data[loc].parent=parent;
+
+          if( -1!=parent && _data[parent].child==p_loc )
+            _data[parent].child=loc;
 
           /*if new parent will be the first root*/
-          if( head==p_loc )
-            head=loc;
-
-          p_loc=container[loc].parent;
-        }
-      }
-      if( comp(value,container[minimum].prio) ) {
-        minimum=i;
-      }
-    }
-
-    /// \brief Increases the priority of \c item to \c value.
-    ///
-    /// This method sets the priority of \c item to \c value. Though
-    /// there is no precondition on the priority of \c item, this
-    /// method should be used only if it is indeed necessary to increase
-    /// (relative to \c Compare) the priority of \c item, because this
-    /// method is inefficient.
+          if( _head==p_loc )
+            _head=loc;
+
+          p_loc=_data[loc].parent;
+        }
+      }
+      if( _comp(value,_data[_min].prio) ) {
+        _min=i;
+      }
+    }
+
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at most \e value.
     void increase (Item item, const Prio& value) {
       erase(item);
@@ -329,16 +337,16 @@
     }
 
-
-    /// \brief Returns if \c item is in, has already been in, or has never
-    /// been in the heap.
-    ///
-    /// This method returns PRE_HEAP if \c item has never been in the
-    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
-    /// otherwise. In the latter case it is possible that \c item will
-    /// get back to the heap again.
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
+    /// \param item The item.
     State state(const Item &item) const {
-      int i=iimap[item];
+      int i=_iim[item];
       if( i>=0 ) {
-        if ( container[i].in ) i=0;
+        if ( _data[i].in ) i=0;
         else i=-2;
       }
@@ -346,9 +354,9 @@
     }
 
-    /// \brief Sets the state of the \c item in the heap.
-    ///
-    /// Sets the state of the \c item in the heap. It can be used to
-    /// manually clear the heap when it is important to achive the
-    /// better time complexity.
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -360,5 +368,5 @@
           erase(i);
         }
-        iimap[i] = st;
+        _iim[i] = st;
         break;
       case IN_HEAP:
@@ -368,18 +376,18 @@
 
   private:
-    int find_min() {
+    int findMin() {
       int min_loc=-1, min_val;
-      int x=head;
+      int x=_head;
       if( x!=-1 ) {
-        min_val=container[x].prio;
+        min_val=_data[x].prio;
         min_loc=x;
-        x=container[x].right_neighbor;
+        x=_data[x].right_neighbor;
 
         while( x!=-1 ) {
-          if( comp( container[x].prio,min_val ) ) {
-            min_val=container[x].prio;
+          if( _comp( _data[x].prio,min_val ) ) {
+            min_val=_data[x].prio;
             min_loc=x;
           }
-          x=container[x].right_neighbor;
+          x=_data[x].right_neighbor;
         }
       }
@@ -390,21 +398,21 @@
       interleave(a);
 
-      int x=head;
+      int x=_head;
       if( -1!=x ) {
-        int x_prev=-1, x_next=container[x].right_neighbor;
+        int x_prev=-1, x_next=_data[x].right_neighbor;
         while( -1!=x_next ) {
-          if( container[x].degree!=container[x_next].degree || ( -1!=container[x_next].right_neighbor && container[container[x_next].right_neighbor].degree==container[x].degree ) ) {
+          if( _data[x].degree!=_data[x_next].degree || ( -1!=_data[x_next].right_neighbor && _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
             x_prev=x;
             x=x_next;
           }
           else {
-            if( comp(container[x].prio,container[x_next].prio) ) {
-              container[x].right_neighbor=container[x_next].right_neighbor;
+            if( _comp(_data[x].prio,_data[x_next].prio) ) {
+              _data[x].right_neighbor=_data[x_next].right_neighbor;
               fuse(x_next,x);
             }
             else {
-              if( -1==x_prev ) { head=x_next; }
+              if( -1==x_prev ) { _head=x_next; }
               else {
-                container[x_prev].right_neighbor=x_next;
+                _data[x_prev].right_neighbor=x_next;
               }
               fuse(x,x_next);
@@ -412,5 +420,5 @@
             }
           }
-          x_next=container[x].right_neighbor;
+          x_next=_data[x].right_neighbor;
         }
       }
@@ -420,66 +428,66 @@
       int other=-1, head_other=-1;
 
-      while( -1!=a || -1!=head ) {
+      while( -1!=a || -1!=_head ) {
         if( -1==a ) {
           if( -1==head_other ) {
-            head_other=head;
+            head_other=_head;
           }
           else {
-            container[other].right_neighbor=head;
-          }
-          head=-1;
-        }
-        else if( -1==head ) {
+            _data[other].right_neighbor=_head;
+          }
+          _head=-1;
+        }
+        else if( -1==_head ) {
           if( -1==head_other ) {
             head_other=a;
           }
           else {
-            container[other].right_neighbor=a;
+            _data[other].right_neighbor=a;
           }
           a=-1;
         }
         else {
-          if( container[a].degree<container[head].degree ) {
+          if( _data[a].degree<_data[_head].degree ) {
             if( -1==head_other ) {
               head_other=a;
             }
             else {
-              container[other].right_neighbor=a;
+              _data[other].right_neighbor=a;
             }
             other=a;
-            a=container[a].right_neighbor;
+            a=_data[a].right_neighbor;
           }
           else {
             if( -1==head_other ) {
-              head_other=head;
+              head_other=_head;
             }
             else {
-              container[other].right_neighbor=head;
+              _data[other].right_neighbor=_head;
             }
-            other=head;
-            head=container[head].right_neighbor;
-          }
-        }
-      }
-      head=head_other;
+            other=_head;
+            _head=_data[_head].right_neighbor;
+          }
+        }
+      }
+      _head=head_other;
     }
 
     // Lacing a under b
     void fuse(int a, int b) {
-      container[a].parent=b;
-      container[a].right_neighbor=container[b].child;
-      container[b].child=a;
-
-      ++container[b].degree;
+      _data[a].parent=b;
+      _data[a].right_neighbor=_data[b].child;
+      _data[b].child=a;
+
+      ++_data[b].degree;
     }
 
     // It is invoked only if a has siblings.
     void unlace(int a) {
-      int neighb=container[a].right_neighbor;
-      int other=head;
-
-      while( container[other].right_neighbor!=a )
-        other=container[other].right_neighbor;
-      container[other].right_neighbor=neighb;
+      int neighb=_data[a].right_neighbor;
+      int other=_head;
+
+      while( _data[other].right_neighbor!=a )
+        other=_data[other].right_neighbor;
+      _data[other].right_neighbor=neighb;
     }
 
Index: lemon/fourary_heap.h
===================================================================
--- lemon/fourary_heap.h	(revision 748)
+++ lemon/fourary_heap.h	(revision 750)
@@ -1,7 +1,7 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,9 +20,8 @@
 #define LEMON_FOURARY_HEAP_H
 
-///\ingroup auxdat
+///\ingroup heaps
 ///\file
-///\brief 4ary Heap implementation.
-
-#include <iostream>
+///\brief Fourary heap implementation.
+
 #include <vector>
 #include <utility>
@@ -31,97 +30,97 @@
 namespace lemon {
 
-  ///\ingroup auxdat
-  ///
-  ///\brief A 4ary Heap implementation.
-  ///
-  ///This class implements the \e 4ary \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.
-  ///
-  ///\param _Prio Type of the priority of the items.
-  ///\param _ItemIntMap A read and writable Item int map, used internally
-  ///to handle the cross references.
-  ///\param _Compare A class for the ordering of the priorities. The
-  ///default is \c std::less<_Prio>.
-  ///
-  ///\sa FibHeap
-  ///\sa Dijkstra
-  ///\author Dorian Batha
-
-  template <typename _Prio, typename _ItemIntMap,
-            typename _Compare = std::less<_Prio> >
-
+  /// \ingroup heaps
+  ///
+  ///\brief Fourary heap data structure.
+  ///
+  /// This class implements the \e fourary \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///
+  /// The fourary heap is a specialization of the \ref KaryHeap "K-ary heap"
+  /// for <tt>K=4</tt>. It is similar to the \ref BinHeap "binary heap",
+  /// but its nodes have at most four children, instead of two.
+  ///
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
+  ///
+  ///\sa BinHeap
+  ///\sa KaryHeap
+#ifdef DOXYGEN
+  template <typename PR, typename IM, typename CMP>
+#else
+  template <typename PR, typename IM, typename CMP = std::less<PR> >
+#endif
   class FouraryHeap {
-
   public:
-    ///\e
-    typedef _ItemIntMap ItemIntMap;
-    ///\e
-    typedef _Prio Prio;
-    ///\e
+    /// 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;
-    ///\e
+    /// Type of the item-priority pairs.
     typedef std::pair<Item,Prio> Pair;
-    ///\e
-    typedef _Compare Compare;
-
-    /// \brief Type to represent the items states.
-    ///
-    /// Each Item element have a state associated to it. It may be "in heap",
-    /// "pre heap" or "post heap". The latter two are indifferent from the
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
-    /// The 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,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
     };
 
   private:
-    std::vector<Pair> data;
-    Compare comp;
-    ItemIntMap &iim;
+    std::vector<Pair> _data;
+    Compare _comp;
+    ItemIntMap &_iim;
 
   public:
-    /// \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.
-    explicit FouraryHeap(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.
-    FouraryHeap(ItemIntMap &_iim, const Compare &_comp)
-      : iim(_iim), comp(_comp) {}
-
-    /// The number of items stored in the heap.
-    ///
-    /// \brief Returns the number of items stored in the heap.
-    int size() const { return data.size(); }
-
-    /// \brief Checks if the heap stores no items.
-    ///
-    /// Returns \c true if and only if the heap stores no items.
-    bool empty() const { return data.empty(); }
-
-    /// \brief Make empty this heap.
-    ///
-    /// Make empty this heap. It does not change the cross reference map.
-    /// If you want to reuse what is not surely empty you should first clear
-    /// the heap and after that you should set the cross reference map for
-    /// each item to \c PRE_HEAP.
-    void clear() { data.clear(); }
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit FouraryHeap(ItemIntMap &map) : _iim(map) {}
+
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    FouraryHeap(ItemIntMap &map, const Compare &comp)
+      : _iim(map), _comp(comp) {}
+
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _data.size(); }
+
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _data.empty(); }
+
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
+    void clear() { _data.clear(); }
 
   private:
@@ -130,25 +129,25 @@
 
     bool less(const Pair &p1, const Pair &p2) const {
-      return comp(p1.second, p2.second);
-    }
-
-    int find_min(const int child, const int length) {
+      return _comp(p1.second, p2.second);
+    }
+
+    int findMin(const int child, const int length) {
       int min=child;
       if( child+3<length ) {
-        if( less(data[child+3], data[min]) )
+        if( less(_data[child+3], _data[min]) )
           min=child+3;
-        if( less(data[child+2], data[min]) )
+        if( less(_data[child+2], _data[min]) )
           min=child+2;
-        if( less(data[child+1], data[min]) )
+        if( less(_data[child+1], _data[min]) )
           min=child+1;
       }
       else if( child+2<length ) {
-        if( less(data[child+2], data[min]) )
+        if( less(_data[child+2], _data[min]) )
           min=child+2;
-        if( less(data[child+1], data[min]) )
+        if( less(_data[child+1], _data[min]) )
           min=child+1;
       }
       else if( child+1<length ) {
-        if( less(data[child+1], data[min]) )
+        if( less(_data[child+1], _data[min]) )
           min=child+1;
       }
@@ -156,8 +155,8 @@
     }
 
-    void bubble_up(int hole, Pair p) {
+    void bubbleUp(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);
@@ -166,11 +165,11 @@
     }
 
-    void bubble_down(int hole, Pair p, int length) {
+    void bubbleDown(int hole, Pair p, int length) {
       int child = firstChild(hole);
       while( child<length && length>1 ) {
-        child = find_min(child,length);
-        if( !less(data[child], p) )
+        child = findMin(child,length);
+        if( !less(_data[child], p) )
           goto ok;
-        move(data[child], hole);
+        move(_data[child], hole);
         hole = child;
         child = firstChild(hole);
@@ -181,140 +180,141 @@
 
     void move(const Pair &p, int i) {
-      data[i] = p;
-      iim.set(p.first, i);
+      _data[i] = p;
+      _iim.set(p.first, i);
     }
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// Adds \c p.first to the heap with priority \c p.second.
+    /// This function inserts \c p.first to the heap with priority
+    /// \c p.second.
     /// \param p The pair to insert.
+    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair &p) {
-      int n = data.size();
-      data.resize(n+1);
-      bubble_up(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given heap.
-    ///
-    /// Adds \c i to the heap with priority \c p.
+      int n = _data.size();
+      _data.resize(n+1);
+      bubbleUp(n, p);
+    }
+
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
     /// \param i The item to insert.
     /// \param p The priority of the item.
+    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
 
-    /// \brief Returns the item with minimum priority relative to \c Compare.
-    ///
-    /// This method returns the item with minimum priority relative to \c
-    /// Compare.
-    /// \pre The heap must be nonempty.
-    Item top() const { return data[0].first; }
-
-    /// \brief Returns the minimum priority relative to \c Compare.
-    ///
-    /// It returns the minimum priority relative to \c Compare.
-    /// \pre The heap must be nonempty.
-    Prio prio() const { return data[0].second; }
-
-    /// \brief Deletes the item with minimum priority relative to \c Compare.
-    ///
-    /// This method deletes the item with minimum priority relative to \c
-    /// Compare from the heap.
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[0].first; }
+
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    Prio prio() const { return _data[0].second; }
+
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
-      int n = data.size()-1;
-      iim.set(data[0].first, POST_HEAP);
-      if (n>0) bubble_down(0, data[n], n);
-      data.pop_back();
-    }
-
-    /// \brief Deletes \c i from the heap.
-    ///
-    /// This method deletes item \c i from the heap.
-    /// \param i The item to erase.
-    /// \pre The item should be in the heap.
+      int n = _data.size()-1;
+      _iim.set(_data[0].first, POST_HEAP);
+      if (n>0) bubbleDown(0, _data[n], n);
+      _data.pop_back();
+    }
+
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param i The item to delete.
+    /// \pre \e i must be in the heap.
     void erase(const Item &i) {
-      int h = iim[i];
-      int n = data.size()-1;
-      iim.set(data[h].first, POST_HEAP);
+      int h = _iim[i];
+      int n = _data.size()-1;
+      _iim.set(_data[h].first, POST_HEAP);
       if( h<n ) {
-        if( less(data[parent(h)], data[n]) )
-          bubble_down(h, data[n], n);
+        if( less(_data[parent(h)], _data[n]) )
+          bubbleDown(h, _data[n], n);
         else
-          bubble_up(h, data[n]);
-      }
-      data.pop_back();
-    }
-
-    /// \brief Returns the priority of \c i.
-    ///
-    /// This function returns the priority of item \c i.
-    /// \pre \c i must be in the heap.
-    /// \param i The item.
+          bubbleUp(h, _data[n]);
+      }
+      _data.pop_back();
+    }
+
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param i The item.
+    /// \pre \e i must be in the heap.
     Prio operator[](const Item &i) const {
-      int idx = iim[i];
-      return data[idx].second;
-    }
-
-    /// \brief \c i gets to the heap with priority \c p independently
-    /// if \c i was already there.
-    ///
-    /// This method calls \ref push(\c i, \c p) if \c i is not stored
-    /// in the heap and sets the priority of \c i to \c p otherwise.
+      int idx = _iim[i];
+      return _data[idx].second;
+    }
+
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
     /// \param i The item.
     /// \param p The priority.
     void set(const Item &i, const Prio &p) {
-      int idx = iim[i];
+      int idx = _iim[i];
       if( idx < 0 )
         push(i,p);
-      else if( comp(p, data[idx].second) )
-        bubble_up(idx, Pair(i,p));
+      else if( _comp(p, _data[idx].second) )
+        bubbleUp(idx, Pair(i,p));
       else
-        bubble_down(idx, Pair(i,p), data.size());
-    }
-
-    /// \brief Decreases the priority of \c i to \c p.
-    ///
-    /// This method decreases the priority of item \c i to \c p.
-    /// \pre \c i must be stored in the heap with priority at least \c
-    /// p relative to \c Compare.
+        bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at least \e p.
     void decrease(const Item &i, const Prio &p) {
-      int idx = iim[i];
-      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.
+      int idx = _iim[i];
+      bubbleUp(idx, Pair(i,p));
+    }
+
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at most \e p.
     void increase(const Item &i, const Prio &p) {
-      int idx = iim[i];
-      bubble_down(idx, Pair(i,p), data.size());
-    }
-
-    /// \brief Returns if \c item is in, has already been in, or has
-    /// never been in the heap.
-    ///
-    /// This method returns PRE_HEAP if \c item has never been in the
-    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
-    /// otherwise. In the latter case it is possible that \c item will
-    /// get back to the heap again.
+      int idx = _iim[i];
+      bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
-      int s = iim[i];
+      int s = _iim[i];
       if (s>=0) s=0;
       return State(s);
     }
 
-    /// \brief Sets the state of the \c item in the heap.
-    ///
-    /// Sets the state of the \c item in the heap. It can be used to
-    /// manually clear the heap when it is important to achive the
-    /// better time complexity.
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -324,5 +324,5 @@
         case PRE_HEAP:
           if (state(i) == IN_HEAP) erase(i);
-          iim[i] = st;
+          _iim[i] = st;
           break;
         case IN_HEAP:
@@ -331,15 +331,16 @@
     }
 
-    /// \brief Replaces an item in the heap.
-    ///
-    /// The \c i item is replaced with \c j item. The \c i item should
-    /// be in the heap, while the \c j should be out of the heap. The
-    /// \c i item will out of the heap and \c j will be in the heap
-    /// with the same prioriority as prevoiusly the \c i item.
+    /// \brief Replace an item in the heap.
+    ///
+    /// This function replaces item \c i with item \c j.
+    /// Item \c i must be in the heap, while \c j must be out of the heap.
+    /// After calling this method, item \c i will be out of the
+    /// heap and \c j will be in the heap with the same prioriority
+    /// as item \c i had before.
     void replace(const Item& i, const Item& j) {
-      int idx = iim[i];
-      iim.set(i, iim[j]);
-      iim.set(j, idx);
-      data[idx].first = j;
+      int idx = _iim[i];
+      _iim.set(i, _iim[j]);
+      _iim.set(j, idx);
+      _data[idx].first = j;
     }
 
Index: lemon/kary_heap.h
===================================================================
--- lemon/kary_heap.h	(revision 748)
+++ lemon/kary_heap.h	(revision 750)
@@ -1,7 +1,7 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
+ *
+ * This file is a part of LEMON, a generic C++ optimization library.
+ *
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,9 +20,8 @@
 #define LEMON_KARY_HEAP_H
 
-///\ingroup auxdat
+///\ingroup heaps
 ///\file
-///\brief Kary Heap implementation.
-
-#include <iostream>
+///\brief Fourary heap implementation.
+
 #include <vector>
 #include <utility>
@@ -31,113 +30,113 @@
 namespace lemon {
 
-  ///\ingroup auxdat
-  ///
-  ///\brief A Kary Heap implementation.
-  ///
-  ///This class implements the \e Kary \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.
-  ///
-  ///\param _Prio Type of the priority of the items.
-  ///\param _ItemIntMap A read and writable Item int map, used internally
-  ///to handle the cross references.
-  ///\param _Compare A class for the ordering of the priorities. The
-  ///default is \c std::less<_Prio>.
-  ///
-  ///\sa FibHeap
-  ///\sa Dijkstra
-  ///\author Dorian Batha
-
-  template <typename _Prio, typename _ItemIntMap,
-            typename _Compare = std::less<_Prio> >
-
+  /// \ingroup heaps
+  ///
+  ///\brief K-ary heap data structure.
+  ///
+  /// This class implements the \e K-ary \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///
+  /// The \ref KaryHeap "K-ary heap" is a generalization of the
+  /// \ref BinHeap "binary heap" structure, its nodes have at most
+  /// \c K children, instead of two.
+  /// \ref BinHeap and \ref FouraryHeap are specialized implementations
+  /// of this structure for <tt>K=2</tt> and <tt>K=4</tt>, respectively.
+  ///
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
+  ///
+  ///\sa BinHeap
+  ///\sa FouraryHeap
+#ifdef DOXYGEN
+  template <typename PR, typename IM, typename CMP>
+#else
+  template <typename PR, typename IM, typename CMP = std::less<PR> >
+#endif
   class KaryHeap {
-
   public:
-    ///\e
-    typedef _ItemIntMap ItemIntMap;
-    ///\e
-    typedef _Prio Prio;
-    ///\e
+    /// 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;
-    ///\e
+    /// Type of the item-priority pairs.
     typedef std::pair<Item,Prio> Pair;
-    ///\e
-    typedef _Compare Compare;
-    ///\e
-
-    /// \brief Type to represent the items states.
-    ///
-    /// Each Item element have a state associated to it. It may be "in heap",
-    /// "pre heap" or "post heap". The latter two are indifferent from the
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
-    /// The 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,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
     };
 
   private:
-    std::vector<Pair> data;
-    Compare comp;
-    ItemIntMap &iim;
-    int K;
+    std::vector<Pair> _data;
+    Compare _comp;
+    ItemIntMap &_iim;
+    int _K;
 
   public:
-    /// \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.
-    explicit KaryHeap(ItemIntMap &_iim, const int &_K=32) : iim(_iim), K(_K) {}
-
-    /// \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.
-    KaryHeap(ItemIntMap &_iim, const Compare &_comp, const int &_K=32)
-      : iim(_iim), comp(_comp), K(_K) {}
-
-
-    /// The number of items stored in the heap.
-    ///
-    /// \brief Returns the number of items stored in the heap.
-    int size() const { return data.size(); }
-
-    /// \brief Checks if the heap stores no items.
-    ///
-    /// Returns \c true if and only if the heap stores no items.
-    bool empty() const { return data.empty(); }
-
-    /// \brief Make empty this heap.
-    ///
-    /// Make empty this heap. It does not change the cross reference map.
-    /// If you want to reuse what is not surely empty you should first clear
-    /// the heap and after that you should set the cross reference map for
-    /// each item to \c PRE_HEAP.
-    void clear() { data.clear(); }
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit KaryHeap(ItemIntMap &map, int K=32) : _iim(map), _K(K) {}
+
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    KaryHeap(ItemIntMap &map, const Compare &comp, int K=32)
+      : _iim(map), _comp(comp), _K(K) {}
+
+    /// \brief The number of items stored in the heap.
+    ///
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _data.size(); }
+
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _data.empty(); }
+
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
+    void clear() { _data.clear(); }
 
   private:
-    int parent(int i) { return (i-1)/K; }
-    int first_child(int i) { return K*i+1; }
+    int parent(int i) { return (i-1)/_K; }
+    int firstChild(int i) { return _K*i+1; }
 
     bool less(const Pair &p1, const Pair &p2) const {
-      return comp(p1.second, p2.second);
-    }
-
-    int find_min(const int child, const int length) {
+      return _comp(p1.second, p2.second);
+    }
+
+    int findMin(const int child, const int length) {
       int min=child, i=1;
-      while( i<K && child+i<length ) {
-        if( less(data[child+i], data[min]) )
+      while( i<_K && child+i<length ) {
+        if( less(_data[child+i], _data[min]) )
           min=child+i;
         ++i;
@@ -146,8 +145,8 @@
     }
 
-    void bubble_up(int hole, Pair p) {
+    void bubbleUp(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);
@@ -156,14 +155,14 @@
     }
 
-    void bubble_down(int hole, Pair p, int length) {
+    void bubbleDown(int hole, Pair p, int length) {
       if( length>1 ) {
-        int child = first_child(hole);
+        int child = firstChild(hole);
         while( child<length ) {
-          child = find_min(child, length);
-          if( !less(data[child], p) )
+          child = findMin(child, length);
+          if( !less(_data[child], p) )
             goto ok;
-          move(data[child], hole);
+          move(_data[child], hole);
           hole = child;
-          child = first_child(hole);
+          child = firstChild(hole);
         }
       }
@@ -173,6 +172,6 @@
 
     void move(const Pair &p, int i) {
-      data[i] = p;
-      iim.set(p.first, i);
+      _data[i] = p;
+      _iim.set(p.first, i);
     }
 
@@ -180,158 +179,160 @@
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// Adds \c p.first to the heap with priority \c p.second.
+    /// This function inserts \c p.first to the heap with priority
+    /// \c p.second.
     /// \param p The pair to insert.
+    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair &p) {
-      int n = data.size();
-      data.resize(n+1);
-      bubble_up(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given heap.
-    ///
-    /// Adds \c i to the heap with priority \c p.
+      int n = _data.size();
+      _data.resize(n+1);
+      bubbleUp(n, p);
+    }
+
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
     /// \param i The item to insert.
     /// \param p The priority of the item.
+    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
 
-    /// \brief Returns the item with minimum priority relative to \c Compare.
-    ///
-    /// This method returns the item with minimum priority relative to \c
-    /// Compare.
-    /// \pre The heap must be nonempty.
-    Item top() const { return data[0].first; }
-
-    /// \brief Returns the minimum priority relative to \c Compare.
-    ///
-    /// It returns the minimum priority relative to \c Compare.
-    /// \pre The heap must be nonempty.
-    Prio prio() const { return data[0].second; }
-
-    /// \brief Deletes the item with minimum priority relative to \c Compare.
-    ///
-    /// This method deletes the item with minimum priority relative to \c
-    /// Compare from the heap.
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[0].first; }
+
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    Prio prio() const { return _data[0].second; }
+
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
-      int n = data.size()-1;
-      iim.set(data[0].first, POST_HEAP);
-      if (n>0) bubble_down(0, data[n], n);
-      data.pop_back();
-    }
-
-    /// \brief Deletes \c i from the heap.
-    ///
-    /// This method deletes item \c i from the heap.
-    /// \param i The item to erase.
-    /// \pre The item should be in the heap.
+      int n = _data.size()-1;
+      _iim.set(_data[0].first, POST_HEAP);
+      if (n>0) bubbleDown(0, _data[n], n);
+      _data.pop_back();
+    }
+
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param i The item to delete.
+    /// \pre \e i must be in the heap.
     void erase(const Item &i) {
-      int h = iim[i];
-      int n = data.size()-1;
-      iim.set(data[h].first, POST_HEAP);
+      int h = _iim[i];
+      int n = _data.size()-1;
+      _iim.set(_data[h].first, POST_HEAP);
       if( h<n ) {
-        if( less(data[parent(h)], data[n]) )
-          bubble_down(h, data[n], n);
+        if( less(_data[parent(h)], _data[n]) )
+          bubbleDown(h, _data[n], n);
         else
-          bubble_up(h, data[n]);
-      }
-      data.pop_back();
-    }
-
-
-    /// \brief Returns the priority of \c i.
-    ///
-    /// This function returns the priority of item \c i.
-    /// \pre \c i must be in the heap.
-    /// \param i The item.
+          bubbleUp(h, _data[n]);
+      }
+      _data.pop_back();
+    }
+
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param i The item.
+    /// \pre \e i must be in the heap.
     Prio operator[](const Item &i) const {
-      int idx = iim[i];
-      return data[idx].second;
-    }
-
-    /// \brief \c i gets to the heap with priority \c p independently
-    /// if \c i was already there.
-    ///
-    /// This method calls \ref push(\c i, \c p) if \c i is not stored
-    /// in the heap and sets the priority of \c i to \c p otherwise.
+      int idx = _iim[i];
+      return _data[idx].second;
+    }
+
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
     /// \param i The item.
     /// \param p The priority.
     void set(const Item &i, const Prio &p) {
-      int idx = iim[i];
+      int idx = _iim[i];
       if( idx<0 )
         push(i,p);
-      else if( comp(p, data[idx].second) )
-        bubble_up(idx, Pair(i,p));
+      else if( _comp(p, _data[idx].second) )
+        bubbleUp(idx, Pair(i,p));
       else
-        bubble_down(idx, Pair(i,p), data.size());
-    }
-
-    /// \brief Decreases the priority of \c i to \c p.
-    ///
-    /// This method decreases the priority of item \c i to \c p.
-    /// \pre \c i must be stored in the heap with priority at least \c
-    /// p relative to \c Compare.
+        bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at least \e p.
     void decrease(const Item &i, const Prio &p) {
-      int idx = iim[i];
-      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.
+      int idx = _iim[i];
+      bubbleUp(idx, Pair(i,p));
+    }
+
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
     /// \param i The item.
     /// \param p The priority.
+    /// \pre \e i must be stored in the heap with priority at most \e p.
     void increase(const Item &i, const Prio &p) {
-      int idx = iim[i];
-      bubble_down(idx, Pair(i,p), data.size());
-    }
-
-    /// \brief Returns if \c item is in, has already been in, or has
-    /// never been in the heap.
-    ///
-    /// This method returns PRE_HEAP if \c item has never been in the
-    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
-    /// otherwise. In the latter case it is possible that \c item will
-    /// get back to the heap again.
+      int idx = _iim[i];
+      bubbleDown(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
-      int s = iim[i];
+      int s = _iim[i];
       if (s>=0) s=0;
       return State(s);
     }
 
-    /// \brief Sets the state of the \c item in the heap.
-    ///
-    /// Sets the state of the \c item in the heap. It can be used to
-    /// manually clear the heap when it is important to achive the
-    /// better time complexity.
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
     void state(const Item& i, State st) {
       switch (st) {
-      case POST_HEAP:
-      case PRE_HEAP:
-        if (state(i) == IN_HEAP) erase(i);
-        iim[i] = st;
-        break;
-      case IN_HEAP:
-        break;
-      }
-    }
-
-    /// \brief Replaces an item in the heap.
-    ///
-    /// The \c i item is replaced with \c j item. The \c i item should
-    /// be in the heap, while the \c j should be out of the heap. The
-    /// \c i item will out of the heap and \c j will be in the heap
-    /// with the same prioriority as prevoiusly the \c i item.
+        case POST_HEAP:
+        case PRE_HEAP:
+          if (state(i) == IN_HEAP) erase(i);
+          _iim[i] = st;
+          break;
+        case IN_HEAP:
+          break;
+      }
+    }
+
+    /// \brief Replace an item in the heap.
+    ///
+    /// This function replaces item \c i with item \c j.
+    /// Item \c i must be in the heap, while \c j must be out of the heap.
+    /// After calling this method, item \c i will be out of the
+    /// heap and \c j will be in the heap with the same prioriority
+    /// as item \c i had before.
     void replace(const Item& i, const Item& j) {
-      int idx=iim[i];
-      iim.set(i, iim[j]);
-      iim.set(j, idx);
-      data[idx].first=j;
+      int idx=_iim[i];
+      _iim.set(i, _iim[j]);
+      _iim.set(j, idx);
+      _data[idx].first=j;
     }
 
Index: lemon/pairing_heap.h
===================================================================
--- lemon/pairing_heap.h	(revision 749)
+++ lemon/pairing_heap.h	(revision 750)
@@ -1,7 +1,7 @@
-/* -*- C++ -*-
+/* -*- mode: C++; indent-tabs-mode: nil; -*-
  *
- * This file is a part of LEMON, a generic C++ optimization library
+ * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2008
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -21,8 +21,9 @@
 
 ///\file
-///\ingroup auxdat
-///\brief Pairing Heap implementation.
+///\ingroup heaps
+///\brief Pairing heap implementation.
 
 #include <vector>
+#include <utility>
 #include <functional>
 #include <lemon/math.h>
@@ -30,206 +31,211 @@
 namespace lemon {
 
-  /// \ingroup auxdat
+  /// \ingroup heaps
   ///
   ///\brief Pairing Heap.
   ///
-  ///This class implements the \e Pairing \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 pairing \e heap data structure.
+  /// It fully conforms to the \ref concepts::Heap "heap concept".
   ///
-  ///The methods \ref increase and \ref erase are not efficient in a Pairing
-  ///heap. In case of many calls to these operations, it is better to use a
-  ///\ref BinHeap "binary heap".
+  /// The methods \ref increase() and \ref erase() are not efficient
+  /// in a pairing heap. In case of many calls of these operations,
+  /// it is better to use other heap structure, e.g. \ref BinHeap
+  /// "binary heap".
   ///
-  ///\param _Prio Type of the priority of the items.
-  ///\param _ItemIntMap A read and writable Item int map, used internally
-  ///to handle the cross references.
-  ///\param _Compare A class for the ordering of the priorities. The
-  ///default is \c std::less<_Prio>.
-  ///
-  ///\sa BinHeap
-  ///\sa Dijkstra
-  ///\author Dorian Batha
-
+  /// \tparam PR Type of the priorities of the items.
+  /// \tparam IM A read-writable item map with \c int values, used
+  /// internally to handle the cross references.
+  /// \tparam CMP A functor class for comparing the priorities.
+  /// The default is \c std::less<PR>.
 #ifdef DOXYGEN
-  template <typename _Prio,
-            typename _ItemIntMap,
-            typename _Compare>
+  template <typename PR, typename IM, typename CMP>
 #else
-  template <typename _Prio,
-            typename _ItemIntMap,
-            typename _Compare = std::less<_Prio> >
+  template <typename PR, typename IM, typename CMP = std::less<PR> >
 #endif
   class PairingHeap {
   public:
-    typedef _ItemIntMap ItemIntMap;
-    typedef _Prio Prio;
+    /// 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;
-    typedef std::pair<Item,Prio> Pair;
-    typedef _Compare Compare;
+    /// Functor type for comparing the priorities.
+    typedef CMP Compare;
+
+    /// \brief Type to represent the states of the items.
+    ///
+    /// Each item has a state associated to it. It can be "in heap",
+    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// heap's point of view, but may be useful to the user.
+    ///
+    /// The item-int map must be initialized in such way that it assigns
+    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    enum State {
+      IN_HEAP = 0,    ///< = 0.
+      PRE_HEAP = -1,  ///< = -1.
+      POST_HEAP = -2  ///< = -2.
+    };
 
   private:
     class store;
 
-    std::vector<store> container;
-    int minimum;
-    ItemIntMap &iimap;
-    Compare comp;
-    int num_items;
+    std::vector<store> _data;
+    int _min;
+    ItemIntMap &_iim;
+    Compare _comp;
+    int _num_items;
 
   public:
-    ///Status of the nodes
-    enum State {
-      ///The node is in the heap
-      IN_HEAP = 0,
-      ///The node has never been in the heap
-      PRE_HEAP = -1,
-      ///The node was in the heap but it got out of it
-      POST_HEAP = -2
-    };
-
-    /// \brief The constructor
-    ///
-    /// \c _iimap should be given to the constructor, since it is
-    ///   used internally to handle the cross references.
-    explicit PairingHeap(ItemIntMap &_iimap)
-      : minimum(0), iimap(_iimap), num_items(0) {}
-
-    /// \brief The constructor
-    ///
-    /// \c _iimap should be given to the constructor, since it is used
-    /// internally to handle the cross references. \c _comp is an
-    /// object for ordering of the priorities.
-    PairingHeap(ItemIntMap &_iimap, const Compare &_comp)
-      : minimum(0), iimap(_iimap), comp(_comp), num_items(0) {}
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    explicit PairingHeap(ItemIntMap &map)
+      : _min(0), _iim(map), _num_items(0) {}
+
+    /// \brief Constructor.
+    ///
+    /// Constructor.
+    /// \param map A map that assigns \c int values to the items.
+    /// It is used internally to handle the cross references.
+    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \param comp The function object used for comparing the priorities.
+    PairingHeap(ItemIntMap &map, const Compare &comp)
+      : _min(0), _iim(map), _comp(comp), _num_items(0) {}
 
     /// \brief The number of items stored in the heap.
     ///
-    /// Returns the number of items stored in the heap.
-    int size() const { return num_items; }
-
-    /// \brief Checks if the heap stores no items.
-    ///
-    ///   Returns \c true if and only if the heap stores no items.
-    bool empty() const { return num_items==0; }
-
-    /// \brief Make empty this heap.
-    ///
-    /// Make empty this heap. It does not change the cross reference
-    /// map.  If you want to reuse a heap what is not surely empty you
-    /// should first clear the heap and after that you should set the
-    /// cross reference map for each item to \c PRE_HEAP.
+    /// This function returns the number of items stored in the heap.
+    int size() const { return _num_items; }
+
+    /// \brief Check if the heap is empty.
+    ///
+    /// This function returns \c true if the heap is empty.
+    bool empty() const { return _num_items==0; }
+
+    /// \brief Make the heap empty.
+    ///
+    /// This functon makes the heap empty.
+    /// It does not change the cross reference map. If you want to reuse
+    /// a heap that is not surely empty, you should first clear it and
+    /// then you should set the cross reference map to \c PRE_HEAP
+    /// for each item.
     void clear() {
-      container.clear();
-      minimum = 0;
-      num_items = 0;
-    }
-
-    /// \brief \c item gets to the heap with priority \c value independently
-    /// if \c item was already there.
-    ///
-    /// This method calls \ref push(\c item, \c value) if \c item is not
-    /// stored in the heap and it calls \ref decrease(\c item, \c value) or
-    /// \ref increase(\c item, \c value) otherwise.
+      _data.clear();
+      _min = 0;
+      _num_items = 0;
+    }
+
+    /// \brief Set the priority of an item or insert it, if it is
+    /// not stored in the heap.
+    ///
+    /// This method sets the priority of the given item if it is
+    /// already stored in the heap. Otherwise it inserts the given
+    /// item into the heap with the given priority.
+    /// \param item The item.
+    /// \param value The priority.
     void set (const Item& item, const Prio& value) {
-      int i=iimap[item];
-      if ( i>=0 && container[i].in ) {
-        if ( comp(value, container[i].prio) ) decrease(item, value);
-        if ( comp(container[i].prio, value) ) increase(item, value);
+      int i=_iim[item];
+      if ( i>=0 && _data[i].in ) {
+        if ( _comp(value, _data[i].prio) ) decrease(item, value);
+        if ( _comp(_data[i].prio, value) ) increase(item, value);
       } else push(item, value);
     }
 
-    /// \brief Adds \c item to the heap with priority \c value.
-    ///
-    /// Adds \c item to the heap with priority \c value.
-    /// \pre \c item must not be stored in the heap.
+    /// \brief Insert an item into the heap with the given priority.
+    ///
+    /// This function inserts the given item into the heap with the
+    /// given priority.
+    /// \param item The item to insert.
+    /// \param value The priority of the item.
+    /// \pre \e item must not be stored in the heap.
     void push (const Item& item, const Prio& value) {
-      int i=iimap[item];
+      int i=_iim[item];
       if( i<0 ) {
-        int s=container.size();
-        iimap.set(item, s);
+        int s=_data.size();
+        _iim.set(item, s);
         store st;
         st.name=item;
-        container.push_back(st);
+        _data.push_back(st);
         i=s;
       } else {
-        container[i].parent=container[i].child=-1;
-        container[i].left_child=false;
-        container[i].degree=0;
-        container[i].in=true;
-      }
-
-      container[i].prio=value;
-
-      if ( num_items!=0 ) {
-        if ( comp( value, container[minimum].prio) ) {
-          fuse(i,minimum);
-          minimum=i;
-        }
-        else fuse(minimum,i);
-      }
-      else minimum=i;
-
-      ++num_items;
-    }
-
-    /// \brief Returns the item with minimum priority relative to \c Compare.
-    ///
-    /// This method returns the item with minimum priority relative to \c
-    /// Compare.
-    /// \pre The heap must be nonempty.
-    Item top() const { return container[minimum].name; }
-
-    /// \brief Returns the minimum priority relative to \c Compare.
-    ///
-    /// It returns the minimum priority relative to \c Compare.
-    /// \pre The heap must be nonempty.
-    const Prio& prio() const { return container[minimum].prio; }
-
-    /// \brief Returns the priority of \c item.
-    ///
-    /// It returns the priority of \c item.
-    /// \pre \c item must be in the heap.
+        _data[i].parent=_data[i].child=-1;
+        _data[i].left_child=false;
+        _data[i].degree=0;
+        _data[i].in=true;
+      }
+
+      _data[i].prio=value;
+
+      if ( _num_items!=0 ) {
+        if ( _comp( value, _data[_min].prio) ) {
+          fuse(i,_min);
+          _min=i;
+        }
+        else fuse(_min,i);
+      }
+      else _min=i;
+
+      ++_num_items;
+    }
+
+    /// \brief Return the item having minimum priority.
+    ///
+    /// This function returns the item having minimum priority.
+    /// \pre The heap must be non-empty.
+    Item top() const { return _data[_min].name; }
+
+    /// \brief The minimum priority.
+    ///
+    /// This function returns the minimum priority.
+    /// \pre The heap must be non-empty.
+    const Prio& prio() const { return _data[_min].prio; }
+
+    /// \brief The priority of the given item.
+    ///
+    /// This function returns the priority of the given item.
+    /// \param item The item.
+    /// \pre \e item must be in the heap.
     const Prio& operator[](const Item& item) const {
-      return container[iimap[item]].prio;
-    }
-
-    /// \brief Deletes the item with minimum priority relative to \c Compare.
-    ///
-    /// This method deletes the item with minimum priority relative to \c
-    /// Compare from the heap.
+      return _data[_iim[item]].prio;
+    }
+
+    /// \brief Remove the item having minimum priority.
+    ///
+    /// This function removes the item having minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
-      int TreeArray[num_items];
+      int TreeArray[_num_items];
       int i=0, num_child=0, child_right = 0;
-      container[minimum].in=false;
-
-      if( -1!=container[minimum].child ) {
-        i=container[minimum].child;
+      _data[_min].in=false;
+
+      if( -1!=_data[_min].child ) {
+        i=_data[_min].child;
         TreeArray[num_child] = i;
-        container[i].parent = -1;
-        container[minimum].child = -1;
+        _data[i].parent = -1;
+        _data[_min].child = -1;
 
         ++num_child;
         int ch=-1;
-        while( container[i].child!=-1 ) {
-          ch=container[i].child;
-          if( container[ch].left_child && i==container[ch].parent ) {
+        while( _data[i].child!=-1 ) {
+          ch=_data[i].child;
+          if( _data[ch].left_child && i==_data[ch].parent ) {
             i=ch;
             //break;
           } else {
-            if( container[ch].left_child ) {
-              child_right=container[ch].parent;
-              container[ch].parent = i;
-              --container[i].degree;
+            if( _data[ch].left_child ) {
+              child_right=_data[ch].parent;
+              _data[ch].parent = i;
+              --_data[i].degree;
             }
             else {
               child_right=ch;
-              container[i].child=-1;
-              container[i].degree=0;
+              _data[i].child=-1;
+              _data[i].degree=0;
             }
-            container[child_right].parent = -1;
+            _data[child_right].parent = -1;
             TreeArray[num_child] = child_right;
             i = child_right;
@@ -240,6 +246,6 @@
         int other;
         for( i=0; i<num_child-1; i+=2 ) {
-          if ( !comp(container[TreeArray[i]].prio,
-                     container[TreeArray[i+1]].prio) ) {
+          if ( !_comp(_data[TreeArray[i]].prio,
+                     _data[TreeArray[i+1]].prio) ) {
             other=TreeArray[i];
             TreeArray[i]=TreeArray[i+1];
@@ -251,6 +257,6 @@
         i = (0==(num_child % 2)) ? num_child-2 : num_child-1;
         while(i>=2) {
-          if ( comp(container[TreeArray[i]].prio,
-                    container[TreeArray[i-2]].prio) ) {
+          if ( _comp(_data[TreeArray[i]].prio,
+                    _data[TreeArray[i-2]].prio) ) {
             other=TreeArray[i];
             TreeArray[i]=TreeArray[i-2];
@@ -260,60 +266,62 @@
           i-=2;
         }
-        minimum = TreeArray[0];
+        _min = TreeArray[0];
       }
 
       if ( 0==num_child ) {
-        minimum = container[minimum].child;
-      }
-
-      if (minimum >= 0) container[minimum].left_child = false;
-
-      --num_items;
-    }
-
-    /// \brief Deletes \c item from the heap.
-    ///
-    /// This method deletes \c item from the heap, if \c item was already
-    /// stored in the heap. It is quite inefficient in Pairing heaps.
+        _min = _data[_min].child;
+      }
+
+      if (_min >= 0) _data[_min].left_child = false;
+
+      --_num_items;
+    }
+
+    /// \brief Remove the given item from the heap.
+    ///
+    /// This function removes the given item from the heap if it is
+    /// already stored.
+    /// \param item The item to delete.
+    /// \pre \e item must be in the heap.
     void erase (const Item& item) {
-      int i=iimap[item];
-      if ( i>=0 && container[i].in ) {
-        decrease( item, container[minimum].prio-1 );
+      int i=_iim[item];
+      if ( i>=0 && _data[i].in ) {
+        decrease( item, _data[_min].prio-1 );
         pop();
       }
     }
 
-    /// \brief Decreases the priority of \c item to \c value.
-    ///
-    /// This method decreases the priority of \c item to \c value.
-    /// \pre \c item must be stored in the heap with priority at least \c
-    ///   value relative to \c Compare.
+    /// \brief Decrease the priority of an item to the given value.
+    ///
+    /// This function decreases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at least \e value.
     void decrease (Item item, const Prio& value) {
-      int i=iimap[item];
-      container[i].prio=value;
-      int p=container[i].parent;
-
-      if( container[i].left_child && i!=container[p].child ) {
-        p=container[p].parent;
-      }
-
-      if ( p!=-1 && comp(value,container[p].prio) ) {
+      int i=_iim[item];
+      _data[i].prio=value;
+      int p=_data[i].parent;
+
+      if( _data[i].left_child && i!=_data[p].child ) {
+        p=_data[p].parent;
+      }
+
+      if ( p!=-1 && _comp(value,_data[p].prio) ) {
         cut(i,p);
-        if ( comp(container[minimum].prio,value) ) {
-          fuse(minimum,i);
+        if ( _comp(_data[_min].prio,value) ) {
+          fuse(_min,i);
         } else {
-          fuse(i,minimum);
-          minimum=i;
-        }
-      }
-    }
-
-    /// \brief Increases the priority of \c item to \c value.
-    ///
-    /// This method sets the priority of \c item to \c value. Though
-    /// there is no precondition on the priority of \c item, this
-    /// method should be used only if it is indeed necessary to increase
-    /// (relative to \c Compare) the priority of \c item, because this
-    /// method is inefficient.
+          fuse(i,_min);
+          _min=i;
+        }
+      }
+    }
+
+    /// \brief Increase the priority of an item to the given value.
+    ///
+    /// This function increases the priority of an item to the given value.
+    /// \param item The item.
+    /// \param value The priority.
+    /// \pre \e item must be stored in the heap with priority at most \e value.
     void increase (Item item, const Prio& value) {
       erase(item);
@@ -321,15 +329,16 @@
     }
 
-    /// \brief Returns if \c item is in, has already been in, or has never
-    /// been in the heap.
-    ///
-    /// This method returns PRE_HEAP if \c item has never been in the
-    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
-    /// otherwise. In the latter case it is possible that \c item will
-    /// get back to the heap again.
+    /// \brief Return the state of an item.
+    ///
+    /// This method returns \c PRE_HEAP if the given item has never
+    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
+    /// and \c POST_HEAP otherwise.
+    /// In the latter case it is possible that the item will get back
+    /// to the heap again.
+    /// \param item The item.
     State state(const Item &item) const {
-      int i=iimap[item];
+      int i=_iim[item];
       if( i>=0 ) {
-        if( container[i].in ) i=0;
+        if( _data[i].in ) i=0;
         else i=-2;
       }
@@ -337,9 +346,9 @@
     }
 
-    /// \brief Sets the state of the \c item in the heap.
-    ///
-    /// Sets the state of the \c item in the heap. It can be used to
-    /// manually clear the heap when it is important to achive the
-    /// better time complexity.
+    /// \brief Set the state of an item in the heap.
+    ///
+    /// This function sets the state of the given item in the heap.
+    /// It can be used to manually clear the heap when it is important
+    /// to achive better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -349,5 +358,5 @@
       case PRE_HEAP:
         if (state(i) == IN_HEAP) erase(i);
-        iimap[i]=st;
+        _iim[i]=st;
         break;
       case IN_HEAP:
@@ -360,53 +369,53 @@
     void cut(int a, int b) {
       int child_a;
-      switch (container[a].degree) {
+      switch (_data[a].degree) {
         case 2:
-          child_a = container[container[a].child].parent;
-          if( container[a].left_child ) {
-            container[child_a].left_child=true;
-            container[b].child=child_a;
-            container[child_a].parent=container[a].parent;
+          child_a = _data[_data[a].child].parent;
+          if( _data[a].left_child ) {
+            _data[child_a].left_child=true;
+            _data[b].child=child_a;
+            _data[child_a].parent=_data[a].parent;
           }
           else {
-            container[child_a].left_child=false;
-            container[child_a].parent=b;
-            if( a!=container[b].child )
-              container[container[b].child].parent=child_a;
+            _data[child_a].left_child=false;
+            _data[child_a].parent=b;
+            if( a!=_data[b].child )
+              _data[_data[b].child].parent=child_a;
             else
-              container[b].child=child_a;
-          }
-          --container[a].degree;
-          container[container[a].child].parent=a;
+              _data[b].child=child_a;
+          }
+          --_data[a].degree;
+          _data[_data[a].child].parent=a;
           break;
 
         case 1:
-          child_a = container[a].child;
-          if( !container[child_a].left_child ) {
-            --container[a].degree;
-            if( container[a].left_child ) {
-              container[child_a].left_child=true;
-              container[child_a].parent=container[a].parent;
-              container[b].child=child_a;
+          child_a = _data[a].child;
+          if( !_data[child_a].left_child ) {
+            --_data[a].degree;
+            if( _data[a].left_child ) {
+              _data[child_a].left_child=true;
+              _data[child_a].parent=_data[a].parent;
+              _data[b].child=child_a;
             }
             else {
-              container[child_a].left_child=false;
-              container[child_a].parent=b;
-              if( a!=container[b].child )
-                container[container[b].child].parent=child_a;
+              _data[child_a].left_child=false;
+              _data[child_a].parent=b;
+              if( a!=_data[b].child )
+                _data[_data[b].child].parent=child_a;
               else
-                container[b].child=child_a;
+                _data[b].child=child_a;
             }
-            container[a].child=-1;
+            _data[a].child=-1;
           }
           else {
-            --container[b].degree;
-            if( container[a].left_child ) {
-              container[b].child =
-                (1==container[b].degree) ? container[a].parent : -1;
+            --_data[b].degree;
+            if( _data[a].left_child ) {
+              _data[b].child =
+                (1==_data[b].degree) ? _data[a].parent : -1;
             } else {
-              if (1==container[b].degree)
-                container[container[b].child].parent=b;
+              if (1==_data[b].degree)
+                _data[_data[b].child].parent=b;
               else
-                container[b].child=-1;
+                _data[b].child=-1;
             }
           }
@@ -414,39 +423,39 @@
 
         case 0:
-          --container[b].degree;
-          if( container[a].left_child ) {
-            container[b].child =
-              (0!=container[b].degree) ? container[a].parent : -1;
+          --_data[b].degree;
+          if( _data[a].left_child ) {
+            _data[b].child =
+              (0!=_data[b].degree) ? _data[a].parent : -1;
           } else {
-            if( 0!=container[b].degree )
-              container[container[b].child].parent=b;
+            if( 0!=_data[b].degree )
+              _data[_data[b].child].parent=b;
             else
-              container[b].child=-1;
+              _data[b].child=-1;
           }
           break;
       }
-      container[a].parent=-1;
-      container[a].left_child=false;
+      _data[a].parent=-1;
+      _data[a].left_child=false;
     }
 
     void fuse(int a, int b) {
-      int child_a = container[a].child;
-      int child_b = container[b].child;
-      container[a].child=b;
-      container[b].parent=a;
-      container[b].left_child=true;
+      int child_a = _data[a].child;
+      int child_b = _data[b].child;
+      _data[a].child=b;
+      _data[b].parent=a;
+      _data[b].left_child=true;
 
       if( -1!=child_a ) {
-        container[b].child=child_a;
-        container[child_a].parent=b;
-        container[child_a].left_child=false;
-        ++container[b].degree;
+        _data[b].child=child_a;
+        _data[child_a].parent=b;
+        _data[child_a].left_child=false;
+        ++_data[b].degree;
 
         if( -1!=child_b ) {
-           container[b].child=child_b;
-           container[child_b].parent=child_a;
-        }
-      }
-      else { ++container[a].degree; }
+           _data[b].child=child_b;
+           _data[child_b].parent=child_a;
+        }
+      }
+      else { ++_data[a].degree; }
     }
 
