Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am	(revision 119)
+++ lemon/Makefile.am	(revision 109)
@@ -21,5 +21,4 @@
         lemon/bfs.h \
         lemon/bin_heap.h \
-        lemon/counter.h \
         lemon/dfs.h \
         lemon/dijkstra.h \
@@ -34,5 +33,4 @@
         lemon/random.h \
 	lemon/smart_graph.h \
-        lemon/time_measure.h \
         lemon/tolerance.h \
 	lemon/unionfind.h
Index: lemon/assert.h
===================================================================
--- lemon/assert.h	(revision 108)
+++ lemon/assert.h	(revision 112)
@@ -116,11 +116,5 @@
 				const char *assertion)
   {
-    std::cerr << file << ":" << line << ": ";
-    if (function)
-      std::cerr << function << ": ";
-    std::cerr << exception.what();
-    if (assertion)
-      std::cerr << " (assertion '" << assertion << "' failed)";
-    std::cerr << std::endl;
+    assert_fail_log(file, line, function, exception, assertion);
     std::abort();
   }
@@ -130,11 +124,5 @@
 				const char *assertion)
   {
-    std::cerr << file << ":" << line << ": ";
-    if (function)
-      std::cerr << function << ": ";
-    std::cerr << message;
-    if (assertion)
-      std::cerr << " (assertion '" << assertion << "' failed)";
-    std::cerr << std::endl;
+    assert_fail_log(file, line, function, message, assertion);
     std::abort();
   }
@@ -145,5 +133,6 @@
 				const char *assertion)
   {
-    assert_fail_abort(file, line, function, message.c_str(), assertion);
+    assert_fail_log(file, line, function, message.c_str(), assertion);
+    std::abort();
   }
 
@@ -169,5 +158,5 @@
 				  const char *assertion)
   {
-    assert_fail_error(file, line, function, message.c_str(), assertion);
+    throw AssertionFailedError(file, line, function, message.c_str(), assertion);
   }
 
@@ -193,5 +182,5 @@
 				    const char *assertion)
   {
-    assert_fail_exception(file, line, function, message.c_str(), assertion);
+    throw AssertionFailedError(file, line, function, message.c_str(), assertion);
   }
 
@@ -209,5 +198,5 @@
   (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +		\
   (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1
-#error "Lemon assertion system is not set properly"
+#error "LEMON assertion system is not set properly"
 #endif
 
@@ -217,7 +206,7 @@
      (defined(LEMON_ASSERT_EXCEPTION) ? 1 : 0) +	\
      (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||	\
-     defined(LEMON_ENABLE_ASSERT)) &&			\
+     defined(LEMON_ENABLE_ASSERTS)) &&			\
   defined(LEMON_DISABLE_ASSERTS)
-#error "Lemon assertion system is not set properly"
+#error "LEMON assertion system is not set properly"
 #endif
 
@@ -257,16 +246,16 @@
 /// \ingroup exceptions
 ///
-/// \brief Macro for assertions with customizable message
-///
-/// Macro for assertions with customizable message.  
-/// \param exp An expression convertible to bool. If the expression is
-/// false, then an assertion is raised. The concrete behaviour depends
-/// on the settings of the assertion system.
-/// \param msg A \e const \e char*, a \e const std::string& or a \e
-/// const \e std::exception& parameter. The variable can be used to
-/// provide information about the circumstances of failed assertion.
-///
-/// The assertions are disabled in the default behaviour. You can
-/// enable the assertions with the following code:
+/// \brief Macro for assertion with customizable message
+///
+/// Macro for assertion with customizable message.  
+/// \param exp An expression that must be convertible to \c bool.
+/// If it is \c false, then an assertion is raised. The concrete
+/// behaviour depends on the settings of the assertion system.
+/// \param msg A <tt>const char*</tt>, a <tt>const std::string&</tt> or
+/// a <tt>const std::exception&</tt> parameter, which can be used to
+/// provide information about the circumstances of the failed assertion.
+///
+/// The assertions are disabled in the default behaviour.
+/// You can enable them with the following code:
 /// \code
 /// #define LEMON_ENABLE_ASSERTS
@@ -278,37 +267,36 @@
 /// \endcode
 /// 
-/// The %lemon assertion system has a wide range of customization
-/// properties. As default behaviour the failed assertion prints a
-/// short log message to the standard ouput and aborts the execution.
+/// The LEMON assertion system has a wide range of customization
+/// properties. As a default behaviour the failed assertion prints a
+/// short log message to the standard error and aborts the execution.
 ///
 /// The following modes can be used in the assertion system: 
 ///
-/// - \e LEMON_ASSERT_LOG The failed assert print a short convenient
-///   error message to the standard error and continues the
-///   execution.
-/// - \e LEMON_ASSERT_ABORT This mode is similar to the \e
-///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
-///   operation mode when the asserts are enabled with \e
-///   LEMON_ENABLE_ASSERTS.
-/// - \e LEMON_ASSERT_ERROR The assert throws an \ref
-///   lemon::AssertionFailedError "AssertionFailedError". If the \c
-///   msg parameter is an exception, then the result of the \ref
-///   lemon::Exception::what() "what()" member function is passed as
-///   error message.
-/// - \e LEMON_ASSERT_EXCEPTION If the specified \c msg is an
-///   exception then it raised directly (solving that the exception
+/// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
+///   message to the standard error and continues the execution.
+/// - \c LEMON_ASSERT_ABORT This mode is similar to the
+///   \c LEMON_ASSERT_LOG, but it aborts the program. It is the default
+///   behaviour mode when the assertions are enabled with
+///   \c LEMON_ENABLE_ASSERTS.
+/// - \c LEMON_ASSERT_ERROR The assertion throws an
+///   \ref lemon::AssertionFailedError "AssertionFailedError".
+///   If the \c msg parameter is an exception, then the result of the
+///   \ref lemon::Exception::what() "what()" member function is passed
+///   as error message.
+/// - \c LEMON_ASSERT_EXCEPTION If the specified \c msg is an
+///   exception, then it raised directly (solving that the exception
 ///   can not be thrown polymorphically), otherwise an \ref
 ///   lemon::AssertionFailedError "AssertionFailedError" is thrown with
-///   the given parameter.
-/// - \e LEMON_ASSERT_CUSTOM The user can define an own assertion
-///   handler functions. Three overloaded functions should be defined
-///   with the following parameter lists:
+///   the given parameters.
+/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
+///   functions. Three overloaded functions should be defined with the
+///   following parameter lists:
 ///   \code
-///     void custom_assert_handler(const char* file, int line, 
-///                                const char* function, const char* message, const char* expression);
-///     void custom_assert_handler(const char* file, int line, 
-///                                const char* function, const std::string& message, const char* expression);
-///     void custom_assert_handler(const char* file, int line, 
-///                                const char* function, const std::exception& message, const char* expression);
+///     void custom_assert_handler(const char* file, int line, const char* function,
+///                                const char* message, const char* assertion);
+///     void custom_assert_handler(const char* file, int line, const char* function,
+///                                const std::string& message, const char* assertion);
+///     void custom_assert_handler(const char* file, int line, const char* function,
+///                                const std::exception& message, const char* assertion);
 ///   \endcode
 ///   The name of the functions should be defined as the \c
@@ -318,10 +306,10 @@
 ///   \endcode
 ///   Whenever an assertion is occured, one of the custom assertion
-///   handler is called with appropiate parameters.
-///
-/// The assertion mode can be changed within one compilation unit, if
-/// the macros are redefined with other settings and the
-/// lemon/assert.h file is reincluded then the behaviour is changed
-/// appropiately to the new settings.
+///   handlers is called with appropiate parameters.
+///
+/// The assertion mode can also be changed within one compilation unit.
+/// If the macros are redefined with other settings and the
+/// \ref lemon/assert.h "assert.h" file is reincluded, then the
+/// behaviour is changed appropiately to the new settings.
 #  define LEMON_ASSERT(exp, msg)					\
   (static_cast<void> (!!(exp) ? 0 : (					\
@@ -347,5 +335,5 @@
 
 #  ifndef LEMON_ASSERT_HANDLER
-#    define LEMON_ASSERT(exp, msg)  (static_cast<void> (0))
+#    define LEMON_ASSERT(exp, msg)  (static_cast<void>(0))
 #    define LEMON_FIXME(msg) (static_cast<void>(0))
 #  else
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 100)
+++ lemon/concepts/heap.h	(revision 113)
@@ -19,6 +19,5 @@
 ///\ingroup concept
 ///\file
-///\brief Classes for representing heaps.
-///
+///\brief The concept of heaps.
 
 #ifndef LEMON_CONCEPT_HEAP_H
@@ -28,29 +27,32 @@
 
 namespace lemon {
+
   namespace concepts {
+
     /// \addtogroup concept
     /// @{
 
-
-    /// \brief A concept structure describes the main interface of heaps.
+    /// \brief The heap concept.
     ///
-    /// A concept structure describes the main interface of heaps.
-    ///
-    template <typename Prio, typename ItemIntMap>
+    /// Concept class describing the main interface of heaps.
+    template <typename Priority, typename ItemIntMap>
     class Heap {
     public:
 
-      ///\brief Type of the items stored in the heap.
-      typedef typename ItemIntMap::Key  Item;
-  
-
-      /// \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 later two are indifferent from the
-      /// heap's point of view, but may be useful to the user.
-      ///
-      /// The ItemIntMap _should_ be initialized in such way, that it maps
-      /// PRE_HEAP (-1) to any element to be put in the heap...
+      /// 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.
+      ///
+      /// Each item has a state associated to it. It can be "in heap",
+      /// "pre heap" or "post heap". The later two are indifferent
+      /// from the point of view of the heap, but may be useful for
+      /// the user.
+      ///
+      /// The \c ItemIntMap must be initialized in such a way, that it 
+      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
       enum State {
 	IN_HEAP = 0,
@@ -62,8 +64,9 @@
       ///
       /// 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 Heap(ItemIntMap &_iim) {}
+      /// \param map A map that assigns \c int values to keys of type
+      /// \c Item. It is used internally by the heap implementations to
+      /// handle the cross references. The assigned value must be
+      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
+      explicit Heap(ItemIntMap &map) {}
 
       /// \brief The number of items stored in the heap.
@@ -72,66 +75,67 @@
       int size() const { return 0; }
 
-      /// \brief Checks if the heap stores no items.
-      ///
-      /// Returns \c true if and only if the heap stores no items.
+      /// \brief Checks if the heap is empty.
+      ///
+      /// Returns \c true if the heap is empty.
       bool empty() const { return false; }
 
-      /// \brief Makes empty this heap.
-      ///
-      /// Makes this heap empty.
+      /// \brief Makes the heap empty.
+      ///
+      /// Makes the heap empty.
       void clear();
 
-      /// \brief Insert an item into the heap with the given heap.
+      /// \brief Inserts an item into the heap with the given priority.
       ///    
-      /// Adds \c i to the heap with priority \c p. 
+      /// Inserts the given item into the heap with the given priority. 
       /// \param i The item to insert.
       /// \param p The priority of the item.
       void push(const Item &i, const Prio &p) {}
 
-      /// \brief Returns the item with minimum priority.
-      ///
-      /// This method returns the item with minimum priority.  
-      /// \pre The heap must be nonempty.  
+      /// \brief Returns the item having minimum priority.
+      ///
+      /// Returns the item having minimum priority.
+      /// \pre The heap must be non-empty.
       Item top() const {}
 
-      /// \brief Returns the minimum priority.
-      ///
-      /// It returns the minimum priority.
-      /// \pre The heap must be nonempty.
+      /// \brief The minimum priority.
+      ///
+      /// Returns the minimum priority.
+      /// \pre The heap must be non-empty.
       Prio prio() const {}
 
-      /// \brief Deletes the item with minimum priority.
-      ///
-      /// This method deletes the item with minimum priority.
-      /// \pre The heap must be non-empty.  
+      /// \brief Removes the item having minimum priority.
+      ///
+      /// Removes the item having minimum priority.
+      /// \pre The heap must be non-empty.
       void pop() {}
 
-      /// \brief Deletes \c i from the heap.
-      ///
-      /// This method deletes item \c i from the heap, if \c i was
+      /// \brief Removes an item from the heap.
+      ///
+      /// Removes the given item from the heap if it is already stored.
+      /// \param i The item to delete. 
+      void erase(const Item &i) {}
+
+      /// \brief The priority of an item.
+      ///
+      /// Returns the priority of the given item.  
+      /// \pre \c i must be in the heap.
+      /// \param i The item.
+      Prio operator[](const Item &i) const {}
+
+      /// \brief Sets the priority of an item or inserts it, if it is
+      /// not stored in the heap.
+      ///
+      /// This method sets the priority of the given item if it is
       /// already stored in the heap.
-      /// \param i The item to erase. 
-      void erase(const Item &i) {}
-
-      /// \brief Returns the priority of \c i.
-      ///
-      /// This function returns the priority of item \c i.  
-      /// \pre \c i must be in the heap.
-      /// \param i The item.
-      Prio operator[](const Item &i) const {}
-
-      /// \brief \c i gets to the heap with priority \c p independently 
-      /// if \c i was already there.
-      ///
-      /// This method calls \ref push(\c i, \c p) if \c i is not stored
-      /// in the heap and sets the priority of \c i to \c p otherwise.
-      /// It may throw an \e UnderFlowPriorityException. 
+      /// Otherwise it inserts the given item with the given priority.
+      ///
+      /// It may throw an \ref UnderflowPriorityException.
       /// \param i The item.
       /// \param p The priority.
       void set(const Item &i, const Prio &p) {}
       
-      /// \brief Decreases the priority of \c i to \c p.
-      ///
-      /// This method decreases the priority of item \c i to \c p.
+      /// \brief Decreases the priority of an item to the given value.
+      ///
+      /// Decreases the priority of an item to the given value.
       /// \pre \c i must be stored in the heap with priority at least \c p.
       /// \param i The item.
@@ -139,30 +143,30 @@
       void decrease(const Item &i, const Prio &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.
+      /// \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) {}
 
-      /// \brief Returns if \c item is in, has already been in, or has 
+      /// \brief Returns if an 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.
+      /// 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 {}
 
-      /// \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
+      /// \brief Sets the state of an item in the heap.
+      ///
+      /// Sets the state of the given item in the heap. It can be used
+      /// to manually clear the heap when it is important to achive the
       /// better time complexity.
       /// \param i The item.
-      /// \param st The state. It should not be \c IN_HEAP. 
+      /// \param st The state. It should not be \c IN_HEAP.
       void state(const Item& i, State st) {}
 
@@ -171,29 +175,44 @@
       struct Constraints {
       public:
-    
 	void constraints() {
+	  typedef typename _Heap::Item OwnItem;
+	  typedef typename _Heap::Prio OwnPrio;
+	  typedef typename _Heap::State OwnState;
+
 	  Item item;
 	  Prio prio;
-
+	  State state;
 	  item=Item();
 	  prio=Prio();
-
 	  ignore_unused_variable_warning(item);
 	  ignore_unused_variable_warning(prio);
-
-	  typedef typename _Heap::State State;
-	  State state;
-
 	  ignore_unused_variable_warning(state);
-      
-	  _Heap heap1 = _Heap(map);
-
+
+	  OwnItem own_item;
+	  OwnPrio own_prio;
+	  OwnState own_state;
+	  own_item=Item();
+	  own_prio=Prio();
+	  ignore_unused_variable_warning(own_item);
+	  ignore_unused_variable_warning(own_prio);
+	  ignore_unused_variable_warning(own_state);
+
+	  _Heap heap1(map);
+	  _Heap heap2 = heap1;
 	  ignore_unused_variable_warning(heap1);
-      
-	  heap.push(item, prio);
+	  ignore_unused_variable_warning(heap2);
+	  
+	  int s = heap.size();
+	  bool e = heap.empty();
 
 	  prio = heap.prio();
 	  item = heap.top();
-
+	  prio = heap[item];
+	  own_prio = heap.prio();
+	  own_item = heap.top();
+	  own_prio = heap[own_item];
+
+	  heap.push(item, prio);
+	  heap.push(own_item, own_prio);
 	  heap.pop();
 
@@ -201,21 +220,27 @@
 	  heap.decrease(item, prio);
 	  heap.increase(item, prio);
-	  prio = heap[item];
+	  heap.set(own_item, own_prio);
+	  heap.decrease(own_item, own_prio);
+	  heap.increase(own_item, own_prio);
 
 	  heap.erase(item);
+	  heap.erase(own_item);
+	  heap.clear();
 
 	  state = heap.state(item);
+	  heap.state(item, state);
+	  state = heap.state(own_item);
+	  heap.state(own_item, own_state);
 
 	  state = _Heap::PRE_HEAP;
 	  state = _Heap::IN_HEAP;
 	  state = _Heap::POST_HEAP;
-
-	  heap.clear();
+	  own_state = _Heap::PRE_HEAP;
+	  own_state = _Heap::IN_HEAP;
+	  own_state = _Heap::POST_HEAP;
 	}
-    
+
 	_Heap& heap;
 	ItemIntMap& map;
-
-	Constraints() : heap(0), map(0) {}
       };
     };
Index: lemon/concepts/maps.h
===================================================================
--- lemon/concepts/maps.h	(revision 94)
+++ lemon/concepts/maps.h	(revision 114)
@@ -25,5 +25,5 @@
 ///\ingroup concept
 ///\file
-///\brief Map concepts checking classes for testing and documenting.
+///\brief The concept of maps.
 
 namespace lemon {
@@ -106,5 +106,5 @@
 	const Value& val;
 	const typename _WriteMap::Key& own_key;
-	const typename _WriteMap::Value own_val;
+	const typename _WriteMap::Value& own_val;
 	_WriteMap& m;
       };
Index: lemon/counter.h
===================================================================
--- lemon/counter.h	(revision 121)
+++ 	(revision )
@@ -1,181 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_COUNTER_H
-#define LEMON_COUNTER_H
-
-#include <string>
-#include <iostream>
-
-///\ingroup timecount
-///\file
-///\brief Tools for counting steps and events
-
-namespace lemon 
-{
-
-  template<class P> class _NoSubCounter;
-
-  template<class P>
-  class _SubCounter 
-  {
-    P &_parent;
-    std::string _title;
-    std::ostream &_os;
-    int count;
-  public:
-
-    typedef _SubCounter<_SubCounter<P> > SubCounter;
-    typedef _NoSubCounter<_SubCounter<P> > NoSubCounter;
-
-    _SubCounter(P &parent)
-      : _parent(parent), _title(), _os(std::cerr), count(0) {}
-    _SubCounter(P &parent,std::string title,std::ostream &os=std::cerr)
-      : _parent(parent), _title(title), _os(os), count(0) {}
-    _SubCounter(P &parent,const char *title,std::ostream &os=std::cerr)
-      : _parent(parent), _title(title), _os(os), count(0) {}
-    ~_SubCounter() { 
-      _os << _title << count <<std::endl;
-      _parent+=count;
-    }
-    _SubCounter &operator++() { count++; return *this;}
-    int operator++(int) { return count++; }
-    _SubCounter &operator--() { count--; return *this;}
-    int operator--(int) { return count--; }
-    _SubCounter &operator+=(int c) { count+=c; return *this;}
-    _SubCounter &operator-=(int c) { count-=c; return *this;}
-    void reset(int c=0) {count=c;}
-    operator int() {return count;}
-  };
-
-  template<class P>
-  class _NoSubCounter 
-  {
-    P &_parent;
-  public:
-    typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;
-    typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;
-  
-    _NoSubCounter(P &parent) :_parent(parent) {}
-    _NoSubCounter(P &parent,std::string,std::ostream &) 
-      :_parent(parent) {}
-    _NoSubCounter(P &parent,std::string) 
-      :_parent(parent) {}
-    _NoSubCounter(P &parent,const char *,std::ostream &)
-      :_parent(parent) {}
-    _NoSubCounter(P &parent,const char *)
-      :_parent(parent) {}
-    ~_NoSubCounter() {}
-    _NoSubCounter &operator++() { ++_parent; return *this;}
-    int operator++(int) { _parent++; return 0;}
-    _NoSubCounter &operator--() { --_parent; return *this;}
-    int operator--(int) { _parent--; return 0;}
-    _NoSubCounter &operator+=(int c) { _parent+=c; return *this;}
-    _NoSubCounter &operator-=(int c) { _parent-=c; return *this;}
-    void reset(int) {}
-    void reset() {}
-    operator int() {return 0;}
-  };
-
-
-  /// \addtogroup timecount
-  /// @{
-
-  ///A counter class
-
-  ///This class makes it easier to count certain events. You can increment
-  ///or decrement the counter using operator++ and operator--.
-  ///A report is automatically printed on destruction.
-  ///\todo More doc
-  class Counter 
-  {
-    std::string _title;
-    std::ostream &_os;
-    int count;
-  public:
-    ///\e
-
-    ///\todo document please.
-    ///
-    typedef _SubCounter<Counter> SubCounter;
-    ///\e
-
-    ///\todo document please.
-    ///
-    typedef _NoSubCounter<Counter> NoSubCounter;
-
-    ///\e
-    Counter() : _title(), _os(std::cerr), count(0) {}
-    ///\e
-    Counter(std::string title,std::ostream &os=std::cerr) 
-      : _title(title), _os(os), count(0) {}
-    ///\e
-    Counter(const char *title,std::ostream &os=std::cerr)
-      : _title(title), _os(os), count(0) {}
-    ///Destructor. Prints the given title and the value of the counter.
-    ~Counter() {
-      _os << _title << count <<std::endl;
-    }
-    ///\e
-    Counter &operator++() { count++; return *this;}
-    ///\e
-    int operator++(int) { return count++;}
-    ///\e
-    Counter &operator--() { count--; return *this;}
-    ///\e
-    int operator--(int) { return count--;}
-    ///\e
-    Counter &operator+=(int c) { count+=c; return *this;}
-    ///\e
-    Counter &operator-=(int c) { count-=c; return *this;}
-    ///\e
-    void reset(int c=0) {count=c;}
-    ///\e
-    operator int() {return count;}
-  };
-
-  ///'Do nothing' version of \ref Counter
-
-  ///'Do nothing' version of \ref Counter.
-  ///\sa Counter
-  class NoCounter
-  {
-  public:
-    typedef _NoSubCounter<NoCounter> SubCounter;
-    typedef _NoSubCounter<NoCounter> NoSubCounter;
-
-    NoCounter() {}
-    NoCounter(std::string,std::ostream &) {}
-    NoCounter(const char *,std::ostream &) {}
-    NoCounter(std::string) {}
-    NoCounter(const char *) {}
-    NoCounter &operator++() { return *this; }
-    int operator++(int) { return 0; }
-    NoCounter &operator--() { return *this; }
-    int operator--(int) { return 0; }
-    NoCounter &operator+=(int) { return *this;}
-    NoCounter &operator-=(int) { return *this;}
-    void reset(int) {}
-    void reset() {}
-    operator int() {return 0;}
-  };
-
-  ///@}
-}
-
-#endif
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 104)
+++ lemon/maps.h	(revision 123)
@@ -117,5 +117,5 @@
 
     /// Constructor with specified initial value.
-    /// \param v is the initial value of the map.
+    /// \param v The initial value of the map.
     ConstMap(const Value &v) : _value(v) {}
 
@@ -142,4 +142,9 @@
   inline ConstMap<K, V> constMap(const V &v) {
     return ConstMap<K, V>(v);
+  }
+
+  template<typename K, typename V>
+  inline ConstMap<K, V> constMap() {
+    return ConstMap<K, V>();
   }
 
@@ -614,5 +619,5 @@
 	   typename V = typename F::result_type>
   class FunctorToMap : public MapBase<K, V> {
-    const F &_f;
+    F _f;
   public:
     typedef MapBase<K, V> Parent;
Index: lemon/random.h
===================================================================
--- lemon/random.h	(revision 110)
+++ lemon/random.h	(revision 116)
@@ -796,5 +796,5 @@
 	  }
       } while(nu>std::pow(xi,delta-1.0)*std::exp(-xi));
-      return theta*(xi-gamma(int(std::floor(k))));
+      return theta*(xi+gamma(int(std::floor(k))));
     }
     
@@ -820,5 +820,5 @@
     double pareto(double k,double x_min)
     {
-      return exponential(gamma(k,1.0/x_min));
+      return exponential(gamma(k,1.0/x_min))+x_min;
     }  
       
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 120)
+++ 	(revision )
@@ -1,541 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2008
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_TIME_MEASURE_H
-#define LEMON_TIME_MEASURE_H
-
-///\ingroup timecount
-///\file
-///\brief Tools for measuring cpu usage
-
-#include <sys/times.h>
-
-#include <sys/time.h>
-#include <fstream>
-#include <iostream>
-#include <unistd.h>
-
-namespace lemon {
-
-  /// \addtogroup timecount
-  /// @{
-
-  /// A class to store (cpu)time instances.
-
-  /// This class stores five time values.
-  /// - a real time
-  /// - a user cpu time
-  /// - a system cpu time
-  /// - a user cpu time of children
-  /// - a system cpu time of children
-  ///
-  /// TimeStamp's can be added to or substracted from each other and
-  /// they can be pushed to a stream.
-  ///
-  /// In most cases, perhaps the \ref Timer or the \ref TimeReport
-  /// class is what you want to use instead.
-  ///
-  ///\author Alpar Juttner
-
-  class TimeStamp
-  {
-    struct rtms 
-    {
-      double tms_utime;
-      double tms_stime;
-      double tms_cutime;
-      double tms_cstime;
-      rtms() {}
-      rtms(tms ts) : tms_utime(ts.tms_utime), tms_stime(ts.tms_stime),
-		     tms_cutime(ts.tms_cutime), tms_cstime(ts.tms_cstime) {}
-    };
-    rtms ts;
-    double real_time;
-  
-    rtms &getTms() {return ts;}
-    const rtms &getTms() const {return ts;}
-
-    void _reset() { 
-      ts.tms_utime = ts.tms_stime = ts.tms_cutime = ts.tms_cstime = 0; 
-      real_time = 0;
-    }
-
-  public:
-
-    ///Read the current time values of the process
-    void stamp()
-    {
-      timeval tv;
-      tms _ts;
-      times(&_ts);
-      gettimeofday(&tv, 0);real_time=tv.tv_sec+double(tv.tv_usec)/1e6;
-      ts=_ts;
-    }
-  
-    /// Constructor initializing with zero
-    TimeStamp()
-    { _reset(); }
-    ///Constructor initializing with the current time values of the process
-    TimeStamp(void *) { stamp();}
-  
-    ///Set every time value to zero
-    TimeStamp &reset() {_reset();return *this;}
-
-    ///\e
-    TimeStamp &operator+=(const TimeStamp &b)
-    {
-      ts.tms_utime+=b.ts.tms_utime;
-      ts.tms_stime+=b.ts.tms_stime;
-      ts.tms_cutime+=b.ts.tms_cutime;
-      ts.tms_cstime+=b.ts.tms_cstime;
-      real_time+=b.real_time;
-      return *this;
-    }
-    ///\e
-    TimeStamp operator+(const TimeStamp &b) const
-    {
-      TimeStamp t(*this);
-      return t+=b;
-    }
-    ///\e
-    TimeStamp &operator-=(const TimeStamp &b)
-    {
-      ts.tms_utime-=b.ts.tms_utime;
-      ts.tms_stime-=b.ts.tms_stime;
-      ts.tms_cutime-=b.ts.tms_cutime;
-      ts.tms_cstime-=b.ts.tms_cstime;
-      real_time-=b.real_time;
-      return *this;
-    }
-    ///\e
-    TimeStamp operator-(const TimeStamp &b) const
-    {
-      TimeStamp t(*this);
-      return t-=b;
-    }
-    ///\e
-    TimeStamp &operator*=(double b)
-    {
-      ts.tms_utime*=b;
-      ts.tms_stime*=b;
-      ts.tms_cutime*=b;
-      ts.tms_cstime*=b;
-      real_time*=b;
-      return *this;
-    }
-    ///\e
-    TimeStamp operator*(double b) const
-    {
-      TimeStamp t(*this);
-      return t*=b;
-    }
-    friend TimeStamp operator*(double b,const TimeStamp &t);
-    ///\e
-    TimeStamp &operator/=(double b)
-    {
-      ts.tms_utime/=b;
-      ts.tms_stime/=b;
-      ts.tms_cutime/=b;
-      ts.tms_cstime/=b;
-      real_time/=b;
-      return *this;
-    }
-    ///\e
-    TimeStamp operator/(double b) const
-    {
-      TimeStamp t(*this);
-      return t/=b;
-    }
-    ///The time ellapsed since the last call of stamp()
-    TimeStamp ellapsed() const
-    {
-      TimeStamp t(NULL);
-      return t-*this;
-    }
-  
-    friend std::ostream& operator<<(std::ostream& os,const TimeStamp &t);
-  
-    ///Gives back the user time of the process
-    double userTime() const
-    {
-      return double(ts.tms_utime)/sysconf(_SC_CLK_TCK);
-    }
-    ///Gives back the system time of the process
-    double systemTime() const
-    {
-      return double(ts.tms_stime)/sysconf(_SC_CLK_TCK);
-    }
-    ///Gives back the user time of the process' children
-    double cUserTime() const
-    {
-      return double(ts.tms_cutime)/sysconf(_SC_CLK_TCK);
-    }
-    ///Gives back the user time of the process' children
-    double cSystemTime() const
-    {
-      return double(ts.tms_cstime)/sysconf(_SC_CLK_TCK);
-    }
-    ///Gives back the real time
-    double realTime() const {return real_time;}
-  };
-
-  TimeStamp operator*(double b,const TimeStamp &t) 
-  {
-    return t*b;
-  }
-  
-  ///Prints the time counters
-
-  ///Prints the time counters in the following form:
-  ///
-  /// <tt>u: XX.XXs s: XX.XXs cu: XX.XXs cs: XX.XXs real: XX.XXs</tt>
-  ///
-  /// where the values are the
-  /// \li \c u: user cpu time,
-  /// \li \c s: system cpu time,
-  /// \li \c cu: user cpu time of children,
-  /// \li \c cs: system cpu time of children,
-  /// \li \c real: real time.
-  /// \relates TimeStamp
-  inline std::ostream& operator<<(std::ostream& os,const TimeStamp &t)
-  {
-    long cls = sysconf(_SC_CLK_TCK);
-    os << "u: " << double(t.getTms().tms_utime)/cls <<
-      "s, s: " << double(t.getTms().tms_stime)/cls <<
-      "s, cu: " << double(t.getTms().tms_cutime)/cls <<
-      "s, cs: " << double(t.getTms().tms_cstime)/cls <<
-      "s, real: " << t.realTime() << "s";
-    return os;
-  }
-
-  ///Class for measuring the cpu time and real time usage of the process
-
-  ///Class for measuring the cpu time and real time usage of the process.
-  ///It is quite easy-to-use, here is a short example.
-  ///\code
-  /// #include<lemon/time_measure.h>
-  /// #include<iostream>
-  ///
-  /// int main()
-  /// {
-  ///
-  ///   ...
-  ///
-  ///   Timer t;
-  ///   doSomething();
-  ///   std::cout << t << '\n';
-  ///   t.restart();
-  ///   doSomethingElse();
-  ///   std::cout << t << '\n';
-  ///
-  ///   ...
-  ///
-  /// }
-  ///\endcode
-  ///
-  ///The \ref Timer can also be \ref stop() "stopped" and
-  ///\ref start() "started" again, so it is possible to compute collected
-  ///running times.
-  ///
-  ///\warning Depending on the operation system and its actual configuration
-  ///the time counters have a certain (10ms on a typical Linux system)
-  ///granularity.
-  ///Therefore this tool is not appropriate to measure very short times.
-  ///Also, if you start and stop the timer very frequently, it could lead to
-  ///distorted results.
-  ///
-  ///\note If you want to measure the running time of the execution of a certain
-  ///function, consider the usage of \ref TimeReport instead.
-  ///
-  ///\todo This shouldn't be Unix (Linux) specific.
-  ///\sa TimeReport
-  ///
-  ///\author Alpar Juttner
-  class Timer
-  {
-    int _running; //Timer is running iff _running>0; (_running>=0 always holds)
-    TimeStamp start_time; //This is the relativ start-time if the timer
-                          //is _running, the collected _running time otherwise.
-    
-    void _reset() {if(_running) start_time.stamp(); else start_time.reset();}
-  
-  public: 
-    ///Constructor.
-
-    ///\param run indicates whether or not the timer starts immediately.
-    ///
-    Timer(bool run=true) :_running(run) {_reset();}
-
-    ///\name Control the state of the timer
-    ///Basically a Timer can be either running or stopped,
-    ///but it provides a bit finer control on the execution.
-    ///The \ref Timer also counts the number of \ref start()
-    ///executions, and is stops only after the same amount (or more)
-    ///\ref stop() "stop()"s. This can be useful e.g. to compute the running time
-    ///of recursive functions.
-    ///
-
-    ///@{
-
-    ///Reset and stop the time counters
-
-    ///This function resets and stops the time counters
-    ///\sa restart()
-    void reset()
-    {
-      _running=0;
-      _reset();
-    }
-
-    ///Start the time counters
-    
-    ///This function starts the time counters.
-    ///
-    ///If the timer is started more than ones, it will remain running
-    ///until the same amount of \ref stop() is called.
-    ///\sa stop()
-    void start() 
-    {
-      if(_running) _running++;
-      else {
-	_running=1;
-	TimeStamp t;
-	t.stamp();
-	start_time=t-start_time;
-      }
-    }
-
-    
-    ///Stop the time counters
-
-    ///This function stops the time counters. If start() was executed more than
-    ///once, then the same number of stop() execution is necessary the really
-    ///stop the timer.
-    /// 
-    ///\sa halt()
-    ///\sa start()
-    ///\sa restart()
-    ///\sa reset()
-
-    void stop() 
-    {
-      if(_running && !--_running) {
-	TimeStamp t;
-	t.stamp();
-	start_time=t-start_time;
-      }
-    }
-
-    ///Halt (i.e stop immediately) the time counters
-
-    ///This function stops immediately the time counters, i.e. <tt>t.halt()</tt>
-    ///is a faster
-    ///equivalent of the following.
-    ///\code
-    ///  while(t.running()) t.stop()
-    ///\endcode
-    ///
-    ///
-    ///\sa stop()
-    ///\sa restart()
-    ///\sa reset()
-
-    void halt() 
-    {
-      if(_running) {
-	_running=0;
-	TimeStamp t;
-	t.stamp();
-	start_time=t-start_time;
-      }
-    }
-
-    ///Returns the running state of the timer
-
-    ///This function returns the number of stop() exections that is
-    ///necessary to really stop the timer.
-    ///For example the timer
-    ///is running if and only if the return value is \c true
-    ///(i.e. greater than
-    ///zero).
-    int running()  { return _running; }
-    
-    
-    ///Restart the time counters
-
-    ///This function is a shorthand for
-    ///a reset() and a start() calls.
-    ///
-    void restart() 
-    {
-      reset();
-      start();
-    }
-    
-    ///@}
-
-    ///\name Query Functions for the ellapsed time
-
-    ///@{
-
-    ///Gives back the ellapsed user time of the process
-    double userTime() const
-    {
-      return operator TimeStamp().userTime();
-    }
-    ///Gives back the ellapsed system time of the process
-    double systemTime() const
-    {
-      return operator TimeStamp().systemTime();
-    }
-    ///Gives back the ellapsed user time of the process' children
-    double cUserTime() const
-    {
-      return operator TimeStamp().cUserTime();
-    }
-    ///Gives back the ellapsed user time of the process' children
-    double cSystemTime() const
-    {
-      return operator TimeStamp().cSystemTime();
-    }
-    ///Gives back the ellapsed real time
-    double realTime() const
-    {
-      return operator TimeStamp().realTime();
-    }
-    ///Computes the ellapsed time
-
-    ///This conversion computes the ellapsed time, therefore you can print
-    ///the ellapsed time like this.
-    ///\code
-    ///  Timer t;
-    ///  doSomething();
-    ///  std::cout << t << '\n';
-    ///\endcode
-    operator TimeStamp () const
-    {
-      TimeStamp t;
-      t.stamp();
-      return _running?t-start_time:start_time;
-    }
-
-
-    ///@}
-  };
-
-  ///Same as \ref Timer but prints a report on destruction.
-
-  ///Same as \ref Timer but prints a report on destruction.
-  ///This example shows its usage.
-  ///\code
-  ///  void myAlg(ListGraph &g,int n)
-  ///  {
-  ///    TimeReport tr("Running time of myAlg: ");
-  ///    ... //Here comes the algorithm
-  ///  }
-  ///\endcode
-  ///
-  ///\sa Timer
-  ///\sa NoTimeReport
-  ///\todo There is no test case for this
-  class TimeReport : public Timer 
-  {
-    std::string _title;
-    std::ostream &_os;
-  public:
-    ///\e
-
-    ///\param title This text will be printed before the ellapsed time.
-    ///\param os The stream to print the report to.
-    ///\param run Sets whether the timer should start immediately.
-
-    TimeReport(std::string title,std::ostream &os=std::cerr,bool run=true) 
-      : Timer(run), _title(title), _os(os){}
-    ///\e Prints the ellapsed time on destruction.
-    ~TimeReport() 
-    {
-      _os << _title << *this << std::endl;
-    }
-  };
-      
-  ///'Do nothing' version of \ref TimeReport
-
-  ///\sa TimeReport
-  ///
-  class NoTimeReport
-  {
-  public:
-    ///\e
-    NoTimeReport(std::string,std::ostream &,bool) {}
-    ///\e
-    NoTimeReport(std::string,std::ostream &) {}
-    ///\e
-    NoTimeReport(std::string) {}
-    ///\e Do nothing.
-    ~NoTimeReport() {}
-
-    operator TimeStamp () const { return TimeStamp(); }
-    void reset() {}
-    void start() {}
-    void stop() {}
-    void halt() {} 
-    int running() { return 0; }
-    void restart() {}
-    double userTime() const { return 0; }
-    double systemTime() const { return 0; }
-    double cUserTime() const { return 0; }
-    double cSystemTime() const { return 0; }
-    double realTime() const { return 0; }
-  };
-      
-  ///Tool to measure the running time more exactly.
-  
-  ///This function calls \c f several times and returns the average
-  ///running time. The number of the executions will be choosen in such a way
-  ///that the full real running time will be roughly between \c min_time
-  ///and <tt>2*min_time</tt>.
-  ///\param f the function object to be measured.
-  ///\param min_time the minimum total running time.
-  ///\retval num if it is not \c NULL, then the actual
-  ///        number of execution of \c f will be written into <tt>*num</tt>.
-  ///\retval full_time if it is not \c NULL, then the actual
-  ///        total running time will be written into <tt>*full_time</tt>.
-  ///\return The average running time of \c f.
-  
-  template<class F>
-  TimeStamp runningTimeTest(F f,double min_time=10,unsigned int *num = NULL,
-                            TimeStamp *full_time=NULL)
-  {
-    TimeStamp full;
-    unsigned int total=0;
-    Timer t;
-    for(unsigned int tn=1;tn <= 1U<<31 && full.realTime()<=min_time; tn*=2) {
-      for(;total<tn;total++) f();
-      full=t;
-    }
-    if(num) *num=total;
-    if(full_time) *full_time=full;
-    return full/total;
-  }
-  
-  /// @}  
-
-
-} //namespace lemon
-
-#endif //LEMON_TIME_MEASURE_H
