Index: .hgignore
===================================================================
--- .hgignore	(revision 866)
+++ .hgignore	(revision 563)
@@ -23,5 +23,4 @@
 lemon/stamp-h2
 doc/Doxyfile
-doc/references.dox
 cmake/version.cmake
 .dirstamp
Index: CMakeLists.txt
===================================================================
--- CMakeLists.txt	(revision 983)
+++ CMakeLists.txt	(revision 975)
@@ -13,45 +13,27 @@
 ELSE()
   EXECUTE_PROCESS(
-    COMMAND
-    hg log -r. --template "{latesttag}"
+    COMMAND ${PYTHON_EXECUTABLE} ./scripts/chg-len.py
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE HG_REVISION_TAG
+    OUTPUT_VARIABLE HG_REVISION_PATH
     ERROR_QUIET
     OUTPUT_STRIP_TRAILING_WHITESPACE
   )
   EXECUTE_PROCESS(
-    COMMAND
-    hg log -r. --template "{latesttagdistance}"
+    COMMAND hg id -i
     WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE HG_REVISION_DIST
+    OUTPUT_VARIABLE HG_REVISION
     ERROR_QUIET
     OUTPUT_STRIP_TRAILING_WHITESPACE
   )
-  EXECUTE_PROCESS(
-    COMMAND
-    hg log -r. --template "{node|short}"
-    WORKING_DIRECTORY ${PROJECT_SOURCE_DIR}
-    OUTPUT_VARIABLE HG_REVISION_ID
-    ERROR_QUIET
-    OUTPUT_STRIP_TRAILING_WHITESPACE
-  )
-
-  IF(HG_REVISION_TAG STREQUAL "")
+  IF(HG_REVISION STREQUAL "")
     SET(HG_REVISION_ID "hg-tip")
   ELSE()
-    IF(HG_REVISION_TAG STREQUAL "null")
-      SET(HG_REVISION_TAG "trunk")
-    ELSEIF(HG_REVISION_TAG MATCHES "^r")
-      STRING(SUBSTRING ${HG_REVISION_TAG} 1 -1 HG_REVISION_TAG)
-    ENDIF()
-    IF(HG_REVISION_DIST STREQUAL "0")
-      SET(HG_REVISION ${HG_REVISION_TAG})
+    IF(HG_REVISION_PATH STREQUAL "")
+      SET(HG_REVISION_ID ${HG_REVISION})
     ELSE()
-      SET(HG_REVISION
-	"${HG_REVISION_TAG}+${HG_REVISION_DIST}-${HG_REVISION_ID}")
+      SET(HG_REVISION_ID ${HG_REVISION_PATH}.${HG_REVISION})
     ENDIF()
   ENDIF()
-
-  SET(LEMON_VERSION ${HG_REVISION} CACHE STRING "LEMON version string.")
+  SET(LEMON_VERSION ${HG_REVISION_ID} CACHE STRING "LEMON version string.")
 ENDIF()
 
@@ -133,26 +115,4 @@
 SET(LEMON_HAVE_LONG_LONG ${HAVE_LONG_LONG})
 
-INCLUDE(FindThreads)
-
-IF(NOT LEMON_THREADING)
-  IF(CMAKE_USE_PTHREADS_INIT)
-    SET(LEMON_THREADING "Pthread")
-  ELSEIF(CMAKE_USE_WIN32_THREADS_INIT)
-    SET(LEMON_THREADING "Win32")
-  ELSE()
-    SET(LEMON_THREADING "None")
-  ENDIF()
-ENDIF()
-
-SET( LEMON_THREADING "${LEMON_THREADING}" CACHE STRING
-  "Choose the threading library, options are: Pthread Win32 None."
-  FORCE )
-
-IF(LEMON_THREADING STREQUAL "Pthread")
-  SET(LEMON_USE_PTHREAD TRUE)
-ELSEIF(LEMON_THREADING STREQUAL "Win32")
-  SET(LEMON_USE_WIN32_THREADS TRUE)
-ENDIF()
-
 ENABLE_TESTING()
 
@@ -165,5 +125,4 @@
 ADD_SUBDIRECTORY(lemon)
 IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
-  ADD_SUBDIRECTORY(contrib)
   ADD_SUBDIRECTORY(demo)
   ADD_SUBDIRECTORY(tools)
@@ -189,31 +148,4 @@
 ENDIF()
 
-CONFIGURE_FILE(
-  ${PROJECT_SOURCE_DIR}/cmake/version.cmake.in
-  ${PROJECT_BINARY_DIR}/cmake/version.cmake
-  @ONLY
-)
-
-SET(ARCHIVE_BASE_NAME ${CMAKE_PROJECT_NAME})
-STRING(TOLOWER ${ARCHIVE_BASE_NAME} ARCHIVE_BASE_NAME)
-SET(ARCHIVE_NAME ${ARCHIVE_BASE_NAME}-${PROJECT_VERSION})
-ADD_CUSTOM_TARGET(dist
-  COMMAND cmake -E remove_directory ${ARCHIVE_NAME}
-  COMMAND hg archive ${ARCHIVE_NAME}
-  COMMAND cmake -E copy cmake/version.cmake ${ARCHIVE_NAME}/cmake/version.cmake
-  COMMAND tar -czf ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_NAME}
-  COMMAND zip -r ${ARCHIVE_BASE_NAME}-nodoc-${PROJECT_VERSION}.zip ${ARCHIVE_NAME}
-  COMMAND cmake -E copy_directory doc/html ${ARCHIVE_NAME}/doc/html
-  COMMAND tar -czf ${ARCHIVE_NAME}.tar.gz ${ARCHIVE_NAME}
-  COMMAND zip -r ${ARCHIVE_NAME}.zip ${ARCHIVE_NAME}
-  COMMAND cmake -E copy_directory doc/html ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  COMMAND tar -czf ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.tar.gz ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  COMMAND zip -r ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}.zip ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  COMMAND cmake -E remove_directory ${ARCHIVE_NAME}
-  COMMAND cmake -E remove_directory ${ARCHIVE_BASE_NAME}-doc-${PROJECT_VERSION}
-  DEPENDS html
-  WORKING_DIRECTORY ${PROJECT_BINARY_DIR})
-
-# CPACK config (Basically for NSIS)
 IF(${CMAKE_SOURCE_DIR} STREQUAL ${PROJECT_SOURCE_DIR})
   SET(CPACK_PACKAGE_NAME ${PROJECT_NAME})
Index: INSTALL
===================================================================
--- INSTALL	(revision 824)
+++ INSTALL	(revision 568)
@@ -174,24 +174,2 @@
 
    Disable COIN-OR support.
-
-
-Makefile Variables
-==================
-
-Some Makefile variables are reserved by the GNU Coding Standards for
-the use of the "user" - the person building the package. For instance,
-CXX and CXXFLAGS are such variables, and have the same meaning as
-explained in the previous section. These variables can be set on the
-command line when invoking `make' like this:
-`make [VARIABLE=VALUE]...'
-
-WARNINGCXXFLAGS is a non-standard Makefile variable introduced by us
-to hold several compiler flags related to warnings. Its default value
-can be overridden when invoking `make'. For example to disable all
-warning flags use `make WARNINGCXXFLAGS='.
-
-In order to turn off a single flag from the default set of warning
-flags, you can use the CXXFLAGS variable, since this is passed after
-WARNINGCXXFLAGS. For example to turn off `-Wold-style-cast' (which is
-used by default when g++ is detected) you can use
-`make CXXFLAGS="-g -O2 -Wno-old-style-cast"'.
Index: LICENSE
===================================================================
--- LICENSE	(revision 879)
+++ LICENSE	(revision 553)
@@ -2,5 +2,5 @@
 copyright/license.
 
-Copyright (C) 2003-2010 Egervary Jeno Kombinatorikus Optimalizalasi
+Copyright (C) 2003-2009 Egervary Jeno Kombinatorikus Optimalizalasi
 Kutatocsoport (Egervary Combinatorial Optimization Research Group,
 EGRES).
Index: Makefile.am
===================================================================
--- Makefile.am	(revision 752)
+++ Makefile.am	(revision 752)
@@ -0,0 +1,79 @@
+ACLOCAL_AMFLAGS = -I m4
+
+AM_CXXFLAGS = $(WARNINGCXXFLAGS)
+
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir)
+LDADD = $(top_builddir)/lemon/libemon.la
+
+EXTRA_DIST = \
+	AUTHORS \
+	LICENSE \
+	m4/lx_check_cplex.m4 \
+	m4/lx_check_glpk.m4 \
+	m4/lx_check_soplex.m4 \
+	m4/lx_check_coin.m4 \
+	CMakeLists.txt \
+	cmake/FindGhostscript.cmake \
+	cmake/FindCPLEX.cmake \
+	cmake/FindGLPK.cmake \
+	cmake/FindCOIN.cmake \
+	cmake/LEMONConfig.cmake.in \
+	cmake/version.cmake.in \
+	cmake/version.cmake \
+	cmake/nsis/lemon.ico \
+	cmake/nsis/uninstall.ico
+
+pkgconfigdir = $(libdir)/pkgconfig
+lemondir = $(pkgincludedir)
+bitsdir = $(lemondir)/bits
+conceptdir = $(lemondir)/concepts
+pkgconfig_DATA =
+lib_LTLIBRARIES =
+lemon_HEADERS =
+bits_HEADERS =
+concept_HEADERS =
+noinst_HEADERS =
+noinst_PROGRAMS =
+bin_PROGRAMS =
+check_PROGRAMS =
+dist_bin_SCRIPTS =
+TESTS =
+XFAIL_TESTS =
+
+include lemon/Makefile.am
+include test/Makefile.am
+include doc/Makefile.am
+include tools/Makefile.am
+
+DIST_SUBDIRS = demo
+
+demo:
+	$(MAKE) $(AM_MAKEFLAGS) -C demo
+
+MRPROPERFILES = \
+	aclocal.m4 \
+	config.h.in \
+	config.h.in~ \
+	configure \
+	Makefile.in \
+	build-aux/config.guess \
+	build-aux/config.sub \
+	build-aux/depcomp \
+	build-aux/install-sh \
+	build-aux/ltmain.sh \
+	build-aux/missing \
+	doc/doxygen.log
+
+mrproper:
+	$(MAKE) $(AM_MAKEFLAGS) maintainer-clean
+	-rm -f $(MRPROPERFILES)
+
+dist-bz2: dist
+	zcat $(PACKAGE)-$(VERSION).tar.gz | \
+	bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2
+
+distcheck-bz2: distcheck
+	zcat $(PACKAGE)-$(VERSION).tar.gz | \
+	bzip2 --best -c > $(PACKAGE)-$(VERSION).tar.bz2
+
+.PHONY: demo mrproper dist-bz2 distcheck-bz2
Index: NEWS
===================================================================
--- NEWS	(revision 881)
+++ NEWS	(revision 665)
@@ -1,82 +1,2 @@
-2010-03-19 Version 1.2 released
-
-        This is major feature release
-
-        * New algorithms
-          * Bellman-Ford algorithm (#51)
-          * Minimum mean cycle algorithms (#179)
-            * Karp, Hartman-Orlin and Howard algorithms
-          * New minimum cost flow algorithms (#180)
-            * Cost Scaling algorithms
-            * Capacity Scaling algorithm
-            * Cycle-Canceling algorithms
-          * Planarity related algorithms (#62)
-            * Planarity checking algorithm
-            * Planar embedding algorithm
-            * Schnyder's planar drawing algorithm
-            * Coloring planar graphs with five or six colors
-          * Fractional matching algorithms (#314)
-        * New data structures
-          * StaticDigraph structure (#68)
-          * Several new priority queue structures (#50, #301)
-            * Fibonacci, Radix, Bucket, Pairing, Binomial
-              D-ary and fourary heaps (#301)
-          * Iterable map structures (#73)
-        * Other new tools and functionality
-          * Map utility functions (#320)
-          * Reserve functions are added to ListGraph and SmartGraph (#311)
-          * A resize() function is added to HypercubeGraph (#311)
-          * A count() function is added to CrossRefMap (#302)
-          * Support for multiple targets in Suurballe using fullInit() (#181)
-          * Traits class and named parameters for Suurballe (#323)
-          * Separate reset() and resetParams() functions in NetworkSimplex
-            to handle graph changes (#327)
-          * tolerance() functions are added to HaoOrlin (#306)
-        * Implementation improvements
-          * Improvements in weighted matching algorithms (#314)
-            * Jumpstart initialization
-          * ArcIt iteration is based on out-arc lists instead of in-arc lists
-            in ListDigraph (#311)
-          * Faster add row operation in CbcMip (#203)
-          * Better implementation for split() in ListDigraph (#311)
-          * ArgParser can also throw exception instead of exit(1) (#332)
-        * Miscellaneous
-          * A simple interactive bootstrap script
-          * Doc improvements (#62,#180,#299,#302,#303,#304,#307,#311,#331,#315,
-                #316,#319)
-            * BibTeX references in the doc (#184)
-          * Optionally use valgrind when running tests
-          * Also check ReferenceMapTag in concept checks (#312)
-          * dimacs-solver uses long long type by default.
-        * Several bugfixes (compared to release 1.1):
-          #295: Suppress MSVC warnings using pragmas
-          ----: Various CMAKE related improvements
-                * Remove duplications from doc/CMakeLists.txt
-                * Rename documentation install folder from 'docs' to 'html'
-                * Add tools/CMakeLists.txt to the tarball
-                * Generate and install LEMONConfig.cmake
-                * Change the label of the html project in Visual Studio
-                * Fix the check for the 'long long' type
-                * Put the version string into config.h
-                * Minor CMake improvements
-                * Set the version to 'hg-tip' if everything fails
-          #311: Add missing 'explicit' keywords
-          #302: Fix the implementation and doc of CrossRefMap
-          #308: Remove duplicate list_graph.h entry from source list
-          #307: Bugfix in Preflow and Circulation
-          #305: Bugfix and extension in the rename script
-          #312: Also check ReferenceMapTag in concept checks
-          #250: Bugfix in pathSource() and pathTarget()
-          #321: Use pathCopy(from,to) instead of copyPath(to,from)
-          #322: Distribure LEMONConfig.cmake.in
-          #330: Bug fix in map_extender.h
-          #336: Fix the date field comment of graphToEps() output
-          #323: Bug fix in Suurballe
-          #335: Fix clear() function in ExtendFindEnum
-          #337: Use void* as the LPX object pointer
-          #317: Fix (and improve) error message in mip_test.cc
-                Remove unnecessary OsiCbc dependency
-          #356: Allow multiple executions of weighted matching algorithms (#356)
-
 2009-05-13 Version 1.1 released
 
@@ -153,5 +73,5 @@
           ----: Add missing unistd.h include to time_measure.h
           #204: Compilation bug fixed in graph_to_eps.h with VS2005
-          #214,#215: windows.h should never be included by LEMON headers
+          #214,#215: windows.h should never be included by lemon headers
           #230: Build systems check the availability of 'long long' type
           #229: Default implementation of Tolerance<> is used for integer types
@@ -175,50 +95,50 @@
 2008-10-13 Version 1.0 released
 
-        This is the first stable release of LEMON. Compared to the 0.x
-        release series, it features a considerably smaller but more
-        matured set of tools. The API has also completely revised and
-        changed in several places.
+	This is the first stable release of LEMON. Compared to the 0.x
+	release series, it features a considerably smaller but more
+	matured set of tools. The API has also completely revised and
+	changed in several places.
 
-        * The major name changes compared to the 0.x series (see the
+	* The major name changes compared to the 0.x series (see the
           Migration Guide in the doc for more details)
           * Graph -> Digraph, UGraph -> Graph
           * Edge -> Arc, UEdge -> Edge
-          * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)
-        * Other improvements
-          * Better documentation
-          * Reviewed and cleaned up codebase
-          * CMake based build system (along with the autotools based one)
-        * Contents of the library (ported from 0.x)
-          * Algorithms
-            * breadth-first search (bfs.h)
-            * depth-first search (dfs.h)
-            * Dijkstra's algorithm (dijkstra.h)
-            * Kruskal's algorithm (kruskal.h)
-          * Data structures
-            * graph data structures (list_graph.h, smart_graph.h)
-            * path data structures (path.h)
-            * binary heap data structure (bin_heap.h)
-            * union-find data structures (unionfind.h)
-            * miscellaneous property maps (maps.h)
-            * two dimensional vector and bounding box (dim2.h)
+	  * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)
+	* Other improvements
+	  * Better documentation
+	  * Reviewed and cleaned up codebase
+	  * CMake based build system (along with the autotools based one)
+	* Contents of the library (ported from 0.x)
+	  * Algorithms
+       	    * breadth-first search (bfs.h)
+       	    * depth-first search (dfs.h)
+       	    * Dijkstra's algorithm (dijkstra.h)
+       	    * Kruskal's algorithm (kruskal.h)
+    	  * Data structures
+       	    * graph data structures (list_graph.h, smart_graph.h)
+       	    * path data structures (path.h)
+       	    * binary heap data structure (bin_heap.h)
+       	    * union-find data structures (unionfind.h)
+       	    * miscellaneous property maps (maps.h)
+       	    * two dimensional vector and bounding box (dim2.h)
           * Concepts
-            * graph structure concepts (concepts/digraph.h, concepts/graph.h,
+       	    * graph structure concepts (concepts/digraph.h, concepts/graph.h,
               concepts/graph_components.h)
-            * concepts for other structures (concepts/heap.h, concepts/maps.h,
-              concepts/path.h)
-          * Tools
-            * Mersenne twister random number generator (random.h)
-            * tools for measuring cpu and wall clock time (time_measure.h)
-            * tools for counting steps and events (counter.h)
-            * tool for parsing command line arguments (arg_parser.h)
-            * tool for visualizing graphs (graph_to_eps.h)
-            * tools for reading and writing data in LEMON Graph Format
+       	    * concepts for other structures (concepts/heap.h, concepts/maps.h,
+	      concepts/path.h)
+    	  * Tools
+       	    * Mersenne twister random number generator (random.h)
+       	    * tools for measuring cpu and wall clock time (time_measure.h)
+       	    * tools for counting steps and events (counter.h)
+       	    * tool for parsing command line arguments (arg_parser.h)
+       	    * tool for visualizing graphs (graph_to_eps.h)
+       	    * tools for reading and writing data in LEMON Graph Format
               (lgf_reader.h, lgf_writer.h)
             * tools to handle the anomalies of calculations with
-              floating point numbers (tolerance.h)
+	      floating point numbers (tolerance.h)
             * tools to manage RGB colors (color.h)
-          * Infrastructure
-            * extended assertion handling (assert.h)
-            * exception classes and error handling (error.h)
-            * concept checking (concept_check.h)
-            * commonly used mathematical constants (math.h)
+    	  * Infrastructure
+       	    * extended assertion handling (assert.h)
+       	    * exception classes and error handling (error.h)
+      	    * concept checking (concept_check.h)
+       	    * commonly used mathematical constants (math.h)
Index: README
===================================================================
--- README	(revision 848)
+++ README	(revision 658)
@@ -18,8 +18,4 @@
    Copying, distribution and modification conditions and terms.
 
-NEWS
-
-   News and version history.
-
 INSTALL
 
@@ -38,8 +34,4 @@
    Some example programs to make you easier to get familiar with LEMON.
 
-scripts/
-
-   Scripts that make it easier to develop LEMON.
-
 test/
 
Index: cmake/version.cmake.in
===================================================================
--- cmake/version.cmake.in	(revision 983)
+++ cmake/version.cmake.in	(revision 678)
@@ -1,1 +1,1 @@
-SET(LEMON_VERSION "@LEMON_VERSION@" CACHE STRING "LEMON version string.")
+SET(LEMON_VERSION "@PACKAGE_VERSION@" CACHE STRING "LEMON version string.")
Index: configure.ac
===================================================================
--- configure.ac	(revision 929)
+++ configure.ac	(revision 929)
@@ -0,0 +1,140 @@
+dnl Process this file with autoconf to produce a configure script.
+
+dnl Version information.
+m4_define([lemon_version_number],
+          [m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])
+dnl m4_define([lemon_version_number], [])
+m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))])
+m4_define([lemon_hg_revision], [m4_normalize(esyscmd([hg id -i 2> /dev/null]))])
+m4_define([lemon_version], [ifelse(lemon_version_number(),
+                           [],
+                           [ifelse(lemon_hg_revision(),
+                           [],
+                           [hg-tip],
+                           [lemon_hg_path().lemon_hg_revision()])],
+                           [lemon_version_number()])])
+
+AC_PREREQ([2.59])
+AC_INIT([LEMON], [lemon_version()], [lemon-user@lemon.cs.elte.hu], [lemon])
+AC_CONFIG_AUX_DIR([build-aux])
+AC_CONFIG_MACRO_DIR([m4])
+AM_INIT_AUTOMAKE([-Wall -Werror foreign subdir-objects nostdinc])
+AC_CONFIG_SRCDIR([lemon/list_graph.h])
+AC_CONFIG_HEADERS([config.h lemon/config.h])
+
+AC_DEFINE([LEMON_VERSION], [lemon_version()], [The version string])
+
+dnl Do compilation tests using the C++ compiler.
+AC_LANG([C++])
+
+dnl Check the existence of long long type.
+AC_CHECK_TYPE(long long, [long_long_found=yes], [long_long_found=no])
+if test x"$long_long_found" = x"yes"; then
+  AC_DEFINE([LEMON_HAVE_LONG_LONG], [1], [Define to 1 if you have long long.])
+fi
+
+dnl Checks for programs.
+AC_PROG_CXX
+AC_PROG_CXXCPP
+AC_PROG_INSTALL
+AC_DISABLE_SHARED
+AC_PROG_LIBTOOL
+
+AC_CHECK_PROG([doxygen_found],[doxygen],[yes],[no])
+AC_CHECK_PROG([gs_found],[gs],[yes],[no])
+
+dnl Detect Intel compiler.
+AC_MSG_CHECKING([whether we are using the Intel C++ compiler])
+AC_COMPILE_IFELSE([#ifndef __INTEL_COMPILER
+choke me
+#endif], [ICC=[yes]], [ICC=[no]])
+if test x"$ICC" = x"yes"; then
+  AC_MSG_RESULT([yes])
+else
+  AC_MSG_RESULT([no])
+fi
+
+dnl Set custom compiler flags when using g++.
+if test "$GXX" = yes -a "$ICC" = no; then
+  WARNINGCXXFLAGS="-Wall -W -Wall -W -Wunused -Wformat=2 -Wctor-dtor-privacy -Wnon-virtual-dtor -Wno-char-subscripts -Wwrite-strings -Wno-char-subscripts -Wreturn-type -Wcast-qual -Wcast-align -Wsign-promo -Woverloaded-virtual -ansi -fno-strict-aliasing -Wold-style-cast -Wno-unknown-pragmas"
+fi
+AC_SUBST([WARNINGCXXFLAGS])
+
+dnl Checks for libraries.
+LX_CHECK_GLPK
+LX_CHECK_CPLEX
+LX_CHECK_SOPLEX
+LX_CHECK_COIN
+
+AM_CONDITIONAL([HAVE_LP], [test x"$lx_lp_found" = x"yes"])
+AM_CONDITIONAL([HAVE_MIP], [test x"$lx_mip_found" = x"yes"])
+
+dnl Disable/enable building the binary tools.
+AC_ARG_ENABLE([tools],
+AS_HELP_STRING([--enable-tools], [build additional tools @<:@default@:>@])
+AS_HELP_STRING([--disable-tools], [do not build additional tools]),
+              [], [enable_tools=yes])
+AC_MSG_CHECKING([whether to build the additional tools])
+if test x"$enable_tools" != x"no"; then
+  AC_MSG_RESULT([yes])
+else
+  AC_MSG_RESULT([no])
+fi
+AM_CONDITIONAL([WANT_TOOLS], [test x"$enable_tools" != x"no"])
+
+dnl Checks for header files.
+AC_CHECK_HEADERS(limits.h sys/time.h sys/times.h unistd.h)
+
+dnl Checks for typedefs, structures, and compiler characteristics.
+AC_C_CONST
+AC_C_INLINE
+AC_TYPE_SIZE_T
+AC_HEADER_TIME
+AC_STRUCT_TM
+
+dnl Checks for library functions.
+AC_HEADER_STDC
+AC_CHECK_FUNCS(gettimeofday times ctime_r)
+
+dnl Add dependencies on files generated by configure.
+AC_SUBST([CONFIG_STATUS_DEPENDENCIES],
+  ['$(top_srcdir)/doc/Doxyfile.in $(top_srcdir)/doc/mainpage.dox.in $(top_srcdir)/lemon/lemon.pc.in $(top_srcdir)/cmake/version.cmake.in'])
+
+AC_CONFIG_FILES([
+Makefile
+demo/Makefile
+cmake/version.cmake
+doc/Doxyfile
+doc/mainpage.dox
+lemon/lemon.pc
+])
+
+AC_OUTPUT
+
+echo
+echo '****************************** SUMMARY ******************************'
+echo
+echo Package version............... : $PACKAGE-$VERSION
+echo
+echo C++ compiler.................. : $CXX
+echo C++ compiles flags............ : $WARNINGCXXFLAGS $CXXFLAGS
+echo
+echo Compiler supports long long... : $long_long_found
+echo
+echo GLPK support.................. : $lx_glpk_found
+echo CPLEX support................. : $lx_cplex_found
+echo SOPLEX support................ : $lx_soplex_found
+echo CLP support................... : $lx_clp_found
+echo CBC support................... : $lx_cbc_found
+echo
+echo Build additional tools........ : $enable_tools
+echo
+echo The packace will be installed in
+echo -n '  '
+echo $prefix.
+echo
+echo '*********************************************************************'
+
+echo
+echo Configure complete, now type \'make\' and then \'make install\'.
+echo
Index: ntrib/CMakeLists.txt
===================================================================
--- contrib/CMakeLists.txt	(revision 925)
+++ 	(revision )
@@ -1,19 +1,0 @@
-INCLUDE_DIRECTORIES(
-  ${PROJECT_SOURCE_DIR}
-  ${PROJECT_BINARY_DIR}
-)
-
-LINK_DIRECTORIES(
-  ${PROJECT_BINARY_DIR}/lemon
-)
-
-# Uncomment (and adjust) the following two lines. 'myprog' is the name
-# of the final executable ('.exe' will automatically be added to the
-# name on Windows) and 'myprog-main.cc' is the source code it is
-# compiled from. You can add more source files separated by
-# whitespaces. Moreover, you can add multiple similar blocks if you
-# want to build more than one executables.
-
-# ADD_EXECUTABLE(myprog myprog-main.cc)
-# TARGET_LINK_LIBRARIES(myprog lemon)
-
Index: demo/Makefile.am
===================================================================
--- demo/Makefile.am	(revision 564)
+++ demo/Makefile.am	(revision 564)
@@ -0,0 +1,17 @@
+AM_CXXFLAGS = $(WARNINGCXXFLAGS)
+
+AM_CPPFLAGS = -I$(top_srcdir) -I$(top_builddir)
+LDADD = $(top_builddir)/lemon/libemon.la
+
+EXTRA_DIST = \
+	CMakeLists.txt \
+	digraph.lgf
+
+noinst_PROGRAMS = \
+	arg_parser_demo \
+	graph_to_eps_demo \
+	lgf_demo
+
+arg_parser_demo_SOURCES = arg_parser_demo.cc
+graph_to_eps_demo_SOURCES = graph_to_eps_demo.cc
+lgf_demo_SOURCES = lgf_demo.cc
Index: demo/arg_parser_demo.cc
===================================================================
--- demo/arg_parser_demo.cc	(revision 877)
+++ demo/arg_parser_demo.cc	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -66,16 +66,7 @@
     .other("...");
 
-  // Throw an exception when problems occurs. The default behavior is to
-  // exit(1) on these cases, but this makes Valgrind falsely warn
-  // about memory leaks.
-  ap.throwOnProblems();
-
   // Perform the parsing process
   // (in case of any error it terminates the program)
-  // The try {} construct is necessary only if the ap.trowOnProblems()
-  // setting is in use.
-  try {
-    ap.parse();
-  } catch (ArgParserException &) { return 1; }
+  ap.parse();
 
   // Check each option if it has been given and print its value
Index: doc/CMakeLists.txt
===================================================================
--- doc/CMakeLists.txt	(revision 983)
+++ doc/CMakeLists.txt	(revision 929)
@@ -18,14 +18,5 @@
 )
 
-# Copy doc from source (if exists)
-IF(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/html AND 
-    NOT EXISTS ${CMAKE_CURRENT_BINARY_DIR}/html/index.html)
-  MESSAGE(STATUS "Copy doc from source tree")
-  EXECUTE_PROCESS(
-    COMMAND cmake -E copy_directory ${CMAKE_CURRENT_SOURCE_DIR}/html ${CMAKE_CURRENT_BINARY_DIR}/html
-    )
-ENDIF()
-
-IF(DOXYGEN_EXECUTABLE AND PYTHONINTERP_FOUND AND GHOSTSCRIPT_EXECUTABLE)
+IF(DOXYGEN_EXECUTABLE AND GHOSTSCRIPT_EXECUTABLE)
   FILE(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/html/)
   SET(GHOSTSCRIPT_OPTIONS -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -sDEVICE=pngalpha)
@@ -38,5 +29,4 @@
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/edge_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/edge_biconnected_components.eps
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/grid_graph.png ${CMAKE_CURRENT_SOURCE_DIR}/images/grid_graph.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/matching.png ${CMAKE_CURRENT_SOURCE_DIR}/images/matching.eps
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/node_biconnected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/node_biconnected_components.eps
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_0.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_0.eps
@@ -45,8 +35,6 @@
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_3.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_3.eps
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/nodeshape_4.png ${CMAKE_CURRENT_SOURCE_DIR}/images/nodeshape_4.eps
-    COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/planar.png ${CMAKE_CURRENT_SOURCE_DIR}/images/planar.eps
     COMMAND ${GHOSTSCRIPT_EXECUTABLE} ${GHOSTSCRIPT_OPTIONS} -r18 -sOutputFile=gen-images/strongly_connected_components.png ${CMAKE_CURRENT_SOURCE_DIR}/images/strongly_connected_components.eps
     COMMAND ${CMAKE_COMMAND} -E remove_directory html
-    COMMAND ${PYTHON_EXECUTABLE} ${PROJECT_SOURCE_DIR}/scripts/bib2dox.py ${CMAKE_CURRENT_SOURCE_DIR}/references.bib >references.dox
     COMMAND ${DOXYGEN_EXECUTABLE} Doxyfile
     WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
Index: doc/Doxyfile.in
===================================================================
--- doc/Doxyfile.in	(revision 966)
+++ doc/Doxyfile.in	(revision 929)
@@ -96,9 +96,7 @@
                          "@abs_top_srcdir@/lemon/concepts" \
                          "@abs_top_srcdir@/demo" \
-                         "@abs_top_srcdir@/contrib" \
                          "@abs_top_srcdir@/tools" \
                          "@abs_top_srcdir@/test/test_tools.h" \
-                         "@abs_top_builddir@/doc/mainpage.dox" \
-                         "@abs_top_builddir@/doc/references.dox"
+                         "@abs_top_builddir@/doc/mainpage.dox"
 INPUT_ENCODING         = UTF-8
 FILE_PATTERNS          = *.h \
Index: doc/Makefile.am
===================================================================
--- doc/Makefile.am	(revision 967)
+++ doc/Makefile.am	(revision 967)
@@ -0,0 +1,110 @@
+EXTRA_DIST += \
+	doc/Doxyfile.in \
+	doc/DoxygenLayout.xml \
+	doc/coding_style.dox \
+	doc/dirs.dox \
+	doc/groups.dox \
+	doc/lgf.dox \
+	doc/license.dox \
+	doc/mainpage.dox \
+	doc/migration.dox \
+	doc/min_cost_flow.dox \
+	doc/named-param.dox \
+	doc/namespaces.dox \
+	doc/template.h \
+	doc/html \
+	doc/CMakeLists.txt
+
+DOC_EPS_IMAGES18 = \
+	grid_graph.eps \
+	nodeshape_0.eps \
+	nodeshape_1.eps \
+	nodeshape_2.eps \
+	nodeshape_3.eps \
+	nodeshape_4.eps
+
+DOC_EPS_IMAGES27 = \
+	bipartite_matching.eps \
+	bipartite_partitions.eps \
+	connected_components.eps \
+	edge_biconnected_components.eps \
+	node_biconnected_components.eps \
+	strongly_connected_components.eps
+
+DOC_EPS_IMAGES = \
+	$(DOC_EPS_IMAGES18) \
+	$(DOC_EPS_IMAGES27)
+
+DOC_PNG_IMAGES = \
+	$(DOC_EPS_IMAGES:%.eps=doc/gen-images/%.png)
+
+EXTRA_DIST += $(DOC_EPS_IMAGES:%=doc/images/%)
+
+doc/html:
+	$(MAKE) $(AM_MAKEFLAGS) html
+
+GS_COMMAND=gs -dNOPAUSE -dBATCH -q -dEPSCrop -dTextAlphaBits=4 -dGraphicsAlphaBits=4
+
+$(DOC_EPS_IMAGES18:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps
+	-mkdir doc/gen-images
+	if test ${gs_found} = yes; then \
+	  $(GS_COMMAND) -sDEVICE=pngalpha -r18 -sOutputFile=$@ $<; \
+	else \
+	  echo; \
+	  echo "Ghostscript not found."; \
+	  echo; \
+	  exit 1; \
+	fi
+
+$(DOC_EPS_IMAGES27:%.eps=doc/gen-images/%.png): doc/gen-images/%.png: doc/images/%.eps
+	-mkdir doc/gen-images
+	if test ${gs_found} = yes; then \
+	  $(GS_COMMAND) -sDEVICE=pngalpha -r27 -sOutputFile=$@ $<; \
+	else \
+	  echo; \
+	  echo "Ghostscript not found."; \
+	  echo; \
+	  exit 1; \
+	fi
+
+html-local: $(DOC_PNG_IMAGES)
+	if test ${doxygen_found} = yes; then \
+	  cd doc; \
+	  doxygen Doxyfile; \
+	  cd ..; \
+	else \
+	  echo; \
+	  echo "Doxygen not found."; \
+	  echo; \
+	  exit 1; \
+	fi
+
+clean-local:
+	-rm -rf doc/html
+	-rm -f doc/doxygen.log
+	-rm -f $(DOC_PNG_IMAGES)
+	-rm -rf doc/gen-images
+
+update-external-tags:
+	wget -O doc/libstdc++.tag.tmp http://gcc.gnu.org/onlinedocs/libstdc++/latest-doxygen/libstdc++.tag && \
+	mv doc/libstdc++.tag.tmp doc/libstdc++.tag || \
+	rm doc/libstdc++.tag.tmp
+
+install-html-local: doc/html
+	@$(NORMAL_INSTALL)
+	$(mkinstalldirs) $(DESTDIR)$(htmldir)/html
+	for p in doc/html/*.{html,css,png,map,gif,tag} ; do \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f"; \
+	  $(INSTALL_DATA) $$p $(DESTDIR)$(htmldir)/html/$$f; \
+	done
+
+uninstall-local:
+	@$(NORMAL_UNINSTALL)
+	for p in doc/html/*.{html,css,png,map,gif,tag} ; do \
+	  f="`echo $$p | sed -e 's|^.*/||'`"; \
+	  echo " rm -f $(DESTDIR)$(htmldir)/html/$$f"; \
+	  rm -f $(DESTDIR)$(htmldir)/html/$$f; \
+	done
+
+.PHONY: update-external-tags
Index: doc/coding_style.dox
===================================================================
--- doc/coding_style.dox	(revision 919)
+++ doc/coding_style.dox	(revision 440)
@@ -99,8 +99,8 @@
 \subsection pri-loc-var Private member variables
 
-Private member variables should start with underscore.
+Private member variables should start with underscore
 
 \code
-_start_with_underscore
+_start_with_underscores
 \endcode
 
Index: doc/dirs.dox
===================================================================
--- doc/dirs.dox	(revision 925)
+++ doc/dirs.dox	(revision 440)
@@ -32,17 +32,4 @@
 documentation.
 */
-
-/**
-\dir contrib
-\brief Directory for user contributed source codes.
-
-You can place your own C++ code using LEMON into this directory, which
-will compile to an executable along with LEMON when you build the
-library. This is probably the easiest way of compiling short to medium
-codes, for this does require neither a LEMON installed system-wide nor
-adding several paths to the compiler.
-
-Please have a look at <tt>contrib/CMakeLists.txt</tt> for
-instruction on how to add your own files into the build process.  */
 
 /**
Index: doc/groups.dox
===================================================================
--- doc/groups.dox	(revision 919)
+++ doc/groups.dox	(revision 663)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -227,4 +227,12 @@
 
 /**
+@defgroup matrices Matrices
+@ingroup datas
+\brief Two dimensional data storages implemented in LEMON.
+
+This group contains two dimensional data storages implemented in LEMON.
+*/
+
+/**
 @defgroup paths Path Structures
 @ingroup datas
@@ -239,26 +247,5 @@
 any kind of path structure.
 
-\sa \ref concepts::Path "Path concept"
-*/
-
-/**
-@defgroup heaps Heap Structures
-@ingroup datas
-\brief %Heap structures implemented in LEMON.
-
-This group contains the heap structures implemented in LEMON.
-
-LEMON provides several heap classes. They are efficient implementations
-of the abstract data type \e priority \e queue. They store items with
-specified values called \e priorities in such a way that finding and
-removing the item with minimum priority are efficient.
-The basic operations are adding and erasing items, changing the priority
-of an item, etc.
-
-Heaps are crucial in several algorithms, such as Dijkstra and Prim.
-The heap implementations have the same interface, thus any of them can be
-used easily in such algorithms.
-
-\sa \ref concepts::Heap "Heap concept"
+\sa lemon::concepts::Path
 */
 
@@ -273,26 +260,4 @@
 
 /**
-@defgroup geomdat Geometric Data Structures
-@ingroup auxdat
-\brief Geometric data structures implemented in LEMON.
-
-This group contains geometric data structures implemented in LEMON.
-
- - \ref lemon::dim2::Point "dim2::Point" implements a two dimensional
-   vector with the usual operations.
- - \ref lemon::dim2::Box "dim2::Box" can be used to determine the
-   rectangular bounding box of a set of \ref lemon::dim2::Point
-   "dim2::Point"'s.
-*/
-
-/**
-@defgroup matrices Matrices
-@ingroup auxdat
-\brief Two dimensional data storages implemented in LEMON.
-
-This group contains two dimensional data storages implemented in LEMON.
-*/
-
-/**
 @defgroup algs Algorithms
 \brief This group contains the several algorithms
@@ -309,6 +274,5 @@
 
 This group contains the common graph search algorithms, namely
-\e breadth-first \e search (BFS) and \e depth-first \e search (DFS)
-\ref clrs01algorithms.
+\e breadth-first \e search (BFS) and \e depth-first \e search (DFS).
 */
 
@@ -318,6 +282,5 @@
 \brief Algorithms for finding shortest paths.
 
-This group contains the algorithms for finding shortest paths in digraphs
-\ref clrs01algorithms.
+This group contains the algorithms for finding shortest paths in digraphs.
 
  - \ref Dijkstra algorithm for finding shortest paths from a source node
@@ -336,13 +299,4 @@
 
 /**
-@defgroup spantree Minimum Spanning Tree Algorithms
-@ingroup algs
-\brief Algorithms for finding minimum cost spanning trees and arborescences.
-
-This group contains the algorithms for finding minimum cost spanning
-trees and arborescences \ref clrs01algorithms.
-*/
-
-/**
 @defgroup max_flow Maximum Flow Algorithms
 @ingroup algs
@@ -350,5 +304,5 @@
 
 This group contains the algorithms for finding maximum flows and
-feasible circulations \ref clrs01algorithms, \ref amo93networkflows.
+feasible circulations.
 
 The \e maximum \e flow \e problem is to find a flow of maximum value between
@@ -365,19 +319,15 @@
 
 LEMON contains several algorithms for solving maximum flow problems:
-- \ref EdmondsKarp Edmonds-Karp algorithm
-  \ref edmondskarp72theoretical.
-- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm
-  \ref goldberg88newapproach.
-- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees
-  \ref dinic70algorithm, \ref sleator83dynamic.
-- \ref GoldbergTarjan !Preflow push-relabel algorithm with dynamic trees
-  \ref goldberg88newapproach, \ref sleator83dynamic.
-
-In most cases the \ref Preflow algorithm provides the
+- \ref EdmondsKarp Edmonds-Karp algorithm.
+- \ref Preflow Goldberg-Tarjan's preflow push-relabel algorithm.
+- \ref DinitzSleatorTarjan Dinitz's blocking flow algorithm with dynamic trees.
+- \ref GoldbergTarjan Preflow push-relabel algorithm with dynamic trees.
+
+In most cases the \ref Preflow "Preflow" algorithm provides the
 fastest method for computing a maximum flow. All implementations
 also provide functions to query the minimum cut, which is the dual
 problem of maximum flow.
 
-\ref Circulation is a preflow push-relabel algorithm implemented directly
+\ref Circulation is a preflow push-relabel algorithm implemented directly 
 for finding feasible circulations, which is a somewhat different problem,
 but it is strongly related to maximum flow.
@@ -392,23 +342,21 @@
 
 This group contains the algorithms for finding minimum cost flows and
-circulations \ref amo93networkflows. For more information about this
-problem and its dual solution, see \ref min_cost_flow
-"Minimum Cost Flow Problem".
+circulations. For more information about this problem and its dual
+solution see \ref min_cost_flow "Minimum Cost Flow Problem".
 
 LEMON contains several algorithms for this problem.
  - \ref NetworkSimplex Primal Network Simplex algorithm with various
-   pivot strategies \ref dantzig63linearprog, \ref kellyoneill91netsimplex.
- - \ref CostScaling Cost Scaling algorithm based on push/augment and
-   relabel operations \ref goldberg90approximation, \ref goldberg97efficient,
-   \ref bunnagel98efficient.
- - \ref CapacityScaling Capacity Scaling algorithm based on the successive
-   shortest path method \ref edmondskarp72theoretical.
- - \ref CycleCanceling Cycle-Canceling algorithms, two of which are
-   strongly polynomial \ref klein67primal, \ref goldberg89cyclecanceling.
-
-In general, \ref NetworkSimplex and \ref CostScaling are the most efficient
-implementations, but the other two algorithms could be faster in special cases.
+   pivot strategies.
+ - \ref CostScaling Push-Relabel and Augment-Relabel algorithms based on
+   cost scaling.
+ - \ref CapacityScaling Successive Shortest %Path algorithm with optional
+   capacity scaling.
+ - \ref CancelAndTighten The Cancel and Tighten algorithm.
+ - \ref CycleCanceling Cycle-Canceling algorithms.
+
+In general NetworkSimplex is the most efficient implementation,
+but in special cases other algorithms could be faster.
 For example, if the total supply and/or capacities are rather small,
-\ref CapacityScaling is usually the fastest algorithm (without effective scaling).
+CapacityScaling is usually the fastest algorithm (without effective scaling).
 */
 
@@ -428,5 +376,5 @@
 
 \f[ \min_{X \subset V, X\not\in \{\emptyset, V\}}
-    \sum_{uv\in A: u\in X, v\not\in X}cap(uv) \f]
+    \sum_{uv\in A, u\in X, v\not\in X}cap(uv) \f]
 
 LEMON contains several algorithms related to minimum cut problems:
@@ -444,38 +392,25 @@
 
 /**
-@defgroup min_mean_cycle Minimum Mean Cycle Algorithms
-@ingroup algs
-\brief Algorithms for finding minimum mean cycles.
-
-This group contains the algorithms for finding minimum mean cycles
-\ref clrs01algorithms, \ref amo93networkflows.
-
-The \e minimum \e mean \e cycle \e problem is to find a directed cycle
-of minimum mean length (cost) in a digraph.
-The mean length of a cycle is the average length of its arcs, i.e. the
-ratio between the total length of the cycle and the number of arcs on it.
-
-This problem has an important connection to \e conservative \e length
-\e functions, too. A length function on the arcs of a digraph is called
-conservative if and only if there is no directed cycle of negative total
-length. For an arbitrary length function, the negative of the minimum
-cycle mean is the smallest \f$\epsilon\f$ value so that increasing the
-arc lengths uniformly by \f$\epsilon\f$ results in a conservative length
-function.
-
-LEMON contains three algorithms for solving the minimum mean cycle problem:
-- \ref KarpMmc Karp's original algorithm \ref amo93networkflows,
-  \ref dasdan98minmeancycle.
-- \ref HartmannOrlinMmc Hartmann-Orlin's algorithm, which is an improved
-  version of Karp's algorithm \ref dasdan98minmeancycle.
-- \ref HowardMmc Howard's policy iteration algorithm
-  \ref dasdan98minmeancycle.
-
-In practice, the \ref HowardMmc "Howard" algorithm turned out to be by far the
-most efficient one, though the best known theoretical bound on its running
-time is exponential.
-Both \ref KarpMmc "Karp" and \ref HartmannOrlinMmc "Hartmann-Orlin" algorithms
-run in time O(ne) and use space O(n<sup>2</sup>+e), but the latter one is
-typically faster due to the applied early termination scheme.
+@defgroup graph_properties Connectivity and Other Graph Properties
+@ingroup algs
+\brief Algorithms for discovering the graph properties
+
+This group contains the algorithms for discovering the graph properties
+like connectivity, bipartiteness, euler property, simplicity etc.
+
+\image html edge_biconnected_components.png
+\image latex edge_biconnected_components.eps "bi-edge-connected components" width=\textwidth
+*/
+
+/**
+@defgroup planar Planarity Embedding and Drawing
+@ingroup algs
+\brief Algorithms for planarity checking, embedding and drawing
+
+This group contains the algorithms for planarity checking,
+embedding and drawing.
+
+\image html planar.png
+\image latex planar.eps "Plane graph" width=\textwidth
 */
 
@@ -515,42 +450,29 @@
   Edmond's blossom shrinking algorithm for calculating maximum weighted
   perfect matching in general graphs.
-- \ref MaxFractionalMatching Push-relabel algorithm for calculating
-  maximum cardinality fractional matching in general graphs.
-- \ref MaxWeightedFractionalMatching Augmenting path algorithm for calculating
-  maximum weighted fractional matching in general graphs.
-- \ref MaxWeightedPerfectFractionalMatching
-  Augmenting path algorithm for calculating maximum weighted
-  perfect fractional matching in general graphs.
-
-\image html matching.png
-\image latex matching.eps "Min Cost Perfect Matching" width=\textwidth
-*/
-
-/**
-@defgroup graph_properties Connectivity and Other Graph Properties
-@ingroup algs
-\brief Algorithms for discovering the graph properties
-
-This group contains the algorithms for discovering the graph properties
-like connectivity, bipartiteness, euler property, simplicity etc.
-
-\image html connected_components.png
-\image latex connected_components.eps "Connected components" width=\textwidth
-*/
-
-/**
-@defgroup planar Planar Embedding and Drawing
-@ingroup algs
-\brief Algorithms for planarity checking, embedding and drawing
-
-This group contains the algorithms for planarity checking,
-embedding and drawing.
-
-\image html planar.png
-\image latex planar.eps "Plane graph" width=\textwidth
-*/
-
-/**
-@defgroup approx_algs Approximation Algorithms
+
+\image html bipartite_matching.png
+\image latex bipartite_matching.eps "Bipartite Matching" width=\textwidth
+*/
+
+/**
+@defgroup spantree Minimum Spanning Tree Algorithms
+@ingroup algs
+\brief Algorithms for finding minimum cost spanning trees and arborescences.
+
+This group contains the algorithms for finding minimum cost spanning
+trees and arborescences.
+*/
+
+/**
+@defgroup auxalg Auxiliary Algorithms
+@ingroup algs
+\brief Auxiliary algorithms implemented in LEMON.
+
+This group contains some algorithms implemented in LEMON
+in order to make it easier to implement complex algorithms.
+*/
+
+/**
+@defgroup approx Approximation Algorithms
 @ingroup algs
 \brief Approximation algorithms.
@@ -558,17 +480,4 @@
 This group contains the approximation and heuristic algorithms
 implemented in LEMON.
-
-<b>Maximum Clique Problem</b>
-  - \ref GrossoLocatelliPullanMc An efficient heuristic algorithm of
-    Grosso, Locatelli, and Pullan.
-*/
-
-/**
-@defgroup auxalg Auxiliary Algorithms
-@ingroup algs
-\brief Auxiliary algorithms implemented in LEMON.
-
-This group contains some algorithms implemented in LEMON
-in order to make it easier to implement complex algorithms.
 */
 
@@ -583,14 +492,11 @@
 
 /**
-@defgroup lp_group LP and MIP Solvers
+@defgroup lp_group Lp and Mip Solvers
 @ingroup gen_opt_group
-\brief LP and MIP solver interfaces for LEMON.
-
-This group contains LP and MIP solver interfaces for LEMON.
-Various LP solvers could be used in the same manner with this
-high-level interface.
-
-The currently supported solvers are \ref glpk, \ref clp, \ref cbc,
-\ref cplex, \ref soplex.
+\brief Lp and Mip solver interfaces for LEMON.
+
+This group contains Lp and Mip solver interfaces for LEMON. The
+various LP solvers could be used in the same manner with this
+interface.
 */
 
@@ -682,5 +588,5 @@
 
 /**
-@defgroup dimacs_group DIMACS Format
+@defgroup dimacs_group DIMACS format
 @ingroup io_group
 \brief Read and write files in DIMACS format
@@ -731,6 +637,6 @@
 \brief Skeleton and concept checking classes for graph structures
 
-This group contains the skeletons and concept checking classes of
-graph structures.
+This group contains the skeletons and concept checking classes of LEMON's
+graph structures and helper classes used to implement these.
 */
 
@@ -744,4 +650,16 @@
 
 /**
+\anchor demoprograms
+
+@defgroup demos Demo Programs
+
+Some demo programs are listed here. Their full source codes can be found in
+the \c demo subdirectory of the source tree.
+
+In order to compile them, use the <tt>make demo</tt> or the
+<tt>make check</tt> commands.
+*/
+
+/**
 @defgroup tools Standalone Utility Applications
 
@@ -752,15 +670,3 @@
 */
 
-/**
-\anchor demoprograms
-
-@defgroup demos Demo Programs
-
-Some demo programs are listed here. Their full source codes can be found in
-the \c demo subdirectory of the source tree.
-
-In order to compile them, use the <tt>make demo</tt> or the
-<tt>make check</tt> commands.
-*/
-
 }
Index: c/images/matching.eps
===================================================================
--- doc/images/matching.eps	(revision 865)
+++ 	(revision )
@@ -1,130 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Sun Mar 14 09:08:34 2010
-%%BoundingBox: -353 -264 559 292
-%%EndComments
-/lb { setlinewidth setrgbcolor newpath moveto
-      4 2 roll 1 index 1 index curveto stroke } bind def
-/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def
-/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def
-/sq { newpath 2 index 1 index add 2 index 2 index add moveto
-      2 index 1 index sub 2 index 2 index add lineto
-      2 index 1 index sub 2 index 2 index sub lineto
-      2 index 1 index add 2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/di { newpath 2 index 1 index add 2 index moveto
-      2 index             2 index 2 index add lineto
-      2 index 1 index sub 2 index             lineto
-      2 index             2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill
-     setrgbcolor 1.1 div c fill
-   } bind def
-/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill
-     setrgbcolor 1.1 div sq fill
-   } bind def
-/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill
-     setrgbcolor 1.1 div di fill
-   } bind def
-/nfemale { 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto 5 index 5 index 5 index 3.01 mul sub
-  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto
-  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/nmale {
-  0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto
-  5 index 4 index 1 mul 1.5 mul add
-  5 index 5 index 3 sqrt 1.5 mul mul add
-  1 index 1 index lineto
-  1 index 1 index 7 index sub moveto
-  1 index 1 index lineto
-  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto
-  stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/arrl 1 def
-/arrw 0.3 def
-/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def
-/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def
-       /w exch def /len exch def
-       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto
-       len w sub arrl sub dx dy lrl
-       arrw dy dx neg lrl
-       dx arrl w add mul dy w 2 div arrw add mul sub
-       dy arrl w add mul dx w 2 div arrw add mul add rlineto
-       dx arrl w add mul neg dy w 2 div arrw add mul sub
-       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto
-       arrw dy dx neg lrl
-       len w sub arrl sub neg dx dy lrl
-       closepath fill } bind def
-/cshow { 2 index 2 index moveto dup stringwidth pop
-         neg 2 div fosi .35 mul neg rmoveto show pop pop} def
-
-gsave
-%Arcs:
-gsave
-140.321 266.249 -327.729 150.06 0 0 0 4.99223 l
-82.1207 -238.726 -245.288 -110.743 0 0 0 4.99223 l
-336.635 -229.036 533.603 13.109 0 0 0 4.99223 l
-53.8598 -45.8071 -245.288 -110.743 0 0 0 4.99223 l
--75.5617 118.579 -327.729 150.06 0 0 0 4.99223 l
--327.729 150.06 -245.288 -110.743 1 0 0 11.9813 l
-533.603 13.109 218.184 -84.2955 0 0 0 4.99223 l
-39.87 175.035 141.163 67.2575 0 0 0 4.99223 l
-53.8598 -45.8071 -75.5617 118.579 0 0 0 4.99223 l
--102.406 -141.267 82.1207 -238.726 0 0 0 4.99223 l
-399.144 166.894 533.603 13.109 1 0 0 11.9813 l
-39.87 175.035 140.321 266.249 1 0 0 11.9813 l
-399.144 166.894 140.321 266.249 0 0 0 4.99223 l
-399.144 166.894 141.163 67.2575 0 0 0 4.99223 l
-53.8598 -45.8071 204.765 -173.77 0 0 0 4.99223 l
-82.1207 -238.726 204.765 -173.77 0 0 0 4.99223 l
-258.227 61.658 399.144 166.894 0 0 0 4.99223 l
-53.8598 -45.8071 -102.406 -141.267 1 0 0 11.9813 l
-175.073 -37.4477 141.163 67.2575 0 0 0 4.99223 l
-258.227 61.658 380 0 0 0 0 4.99223 l
-34.6739 40.8267 -75.5617 118.579 1 0 0 11.9813 l
-380 0 533.603 13.109 0 0 0 4.99223 l
-175.073 -37.4477 380 0 0 0 0 4.99223 l
-218.184 -84.2955 204.765 -173.77 0 0 0 4.99223 l
-53.8598 -45.8071 34.6739 40.8267 0 0 0 4.99223 l
-167.905 -213.988 82.1207 -238.726 1 0 0 11.9813 l
-336.635 -229.036 204.765 -173.77 1 0 0 11.9813 l
-336.635 -229.036 167.905 -213.988 0 0 0 4.99223 l
-329.08 -26.3098 218.184 -84.2955 0 0 0 4.99223 l
-39.87 175.035 -75.5617 118.579 0 0 0 4.99223 l
-53.8598 -45.8071 175.073 -37.4477 0 0 0 4.99223 l
-34.6739 40.8267 141.163 67.2575 0 0 0 4.99223 l
-258.227 61.658 141.163 67.2575 1 0 0 11.9813 l
-175.073 -37.4477 218.184 -84.2955 1 0 0 11.9813 l
-380 0 329.08 -26.3098 1 0 0 11.9813 l
-grestore
-%Nodes:
-gsave
--245.288 -110.743 14.9767 1 1 1 nc
-204.765 -173.77 14.9767 1 1 1 nc
--327.729 150.06 14.9767 1 1 1 nc
--75.5617 118.579 14.9767 1 1 1 nc
-218.184 -84.2955 14.9767 1 1 1 nc
-140.321 266.249 14.9767 1 1 1 nc
-141.163 67.2575 14.9767 1 1 1 nc
-82.1207 -238.726 14.9767 1 1 1 nc
-329.08 -26.3098 14.9767 1 1 1 nc
--102.406 -141.267 14.9767 1 1 1 nc
-533.603 13.109 14.9767 1 1 1 nc
-167.905 -213.988 14.9767 1 1 1 nc
-336.635 -229.036 14.9767 1 1 1 nc
-380 0 14.9767 1 1 1 nc
-399.144 166.894 14.9767 1 1 1 nc
-34.6739 40.8267 14.9767 1 1 1 nc
-39.87 175.035 14.9767 1 1 1 nc
-175.073 -37.4477 14.9767 1 1 1 nc
-53.8598 -45.8071 14.9767 1 1 1 nc
-258.227 61.658 14.9767 1 1 1 nc
-grestore
-grestore
-showpage
Index: c/images/planar.eps
===================================================================
--- doc/images/planar.eps	(revision 827)
+++ 	(revision )
@@ -1,181 +1,0 @@
-%!PS-Adobe-2.0 EPSF-2.0
-%%Creator: LEMON, graphToEps()
-%%CreationDate: Fri Oct 19 18:32:32 2007
-%%BoundingBox: 0 0 596 842
-%%DocumentPaperSizes: a4
-%%EndComments
-/lb { setlinewidth setrgbcolor newpath moveto
-      4 2 roll 1 index 1 index curveto stroke } bind def
-/l { setlinewidth setrgbcolor newpath moveto lineto stroke } bind def
-/c { newpath dup 3 index add 2 index moveto 0 360 arc closepath } bind def
-/sq { newpath 2 index 1 index add 2 index 2 index add moveto
-      2 index 1 index sub 2 index 2 index add lineto
-      2 index 1 index sub 2 index 2 index sub lineto
-      2 index 1 index add 2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/di { newpath 2 index 1 index add 2 index moveto
-      2 index             2 index 2 index add lineto
-      2 index 1 index sub 2 index             lineto
-      2 index             2 index 2 index sub lineto
-      closepath pop pop pop} bind def
-/nc { 0 0 0 setrgbcolor 5 index 5 index 5 index c fill
-     setrgbcolor 1.1 div c fill
-   } bind def
-/nsq { 0 0 0 setrgbcolor 5 index 5 index 5 index sq fill
-     setrgbcolor 1.1 div sq fill
-   } bind def
-/ndi { 0 0 0 setrgbcolor 5 index 5 index 5 index di fill
-     setrgbcolor 1.1 div di fill
-   } bind def
-/nfemale { 0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto 5 index 5 index 5 index 3.01 mul sub
-  lineto 5 index 4 index .7 mul sub 5 index 5 index 2.2 mul sub moveto
-  5 index 4 index .7 mul add 5 index 5 index 2.2 mul sub lineto stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/nmale {
-  0 0 0 setrgbcolor 3 index 0.0909091 1.5 mul mul setlinewidth
-  newpath 5 index 5 index moveto
-  5 index 4 index 1 mul 1.5 mul add
-  5 index 5 index 3 sqrt 1.5 mul mul add
-  1 index 1 index lineto
-  1 index 1 index 7 index sub moveto
-  1 index 1 index lineto
-  exch 5 index 3 sqrt .5 mul mul sub exch 5 index .5 mul sub lineto
-  stroke
-  5 index 5 index 5 index c fill
-  setrgbcolor 1.1 div c fill
-  } bind def
-/arrl 1 def
-/arrw 0.3 def
-/lrl { 2 index mul exch 2 index mul exch rlineto pop} bind def
-/arr { setrgbcolor /y1 exch def /x1 exch def /dy exch def /dx exch def
-       /w exch def /len exch def
-       newpath x1 dy w 2 div mul add y1 dx w 2 div mul sub moveto
-       len w sub arrl sub dx dy lrl
-       arrw dy dx neg lrl
-       dx arrl w add mul dy w 2 div arrw add mul sub
-       dy arrl w add mul dx w 2 div arrw add mul add rlineto
-       dx arrl w add mul neg dy w 2 div arrw add mul sub
-       dy arrl w add mul neg dx w 2 div arrw add mul add rlineto
-       arrw dy dx neg lrl
-       len w sub arrl sub neg dx dy lrl
-       closepath fill } bind def
-/cshow { 2 index 2 index moveto dup stringwidth pop
-         neg 2 div fosi .35 mul neg rmoveto show pop pop} def
-
-gsave
-15 138.307 translate
-12.7843 dup scale
-90 rotate
-0.608112 -43.6081 translate
-%Edges:
-gsave
-9 31 9.5 30.5 10 30 0 0 0 0.091217 lb
-9 31 5.5 34.5 2 38 0 0 0 0.091217 lb
-9 31 25.5 16 42 1 0 0 0 0.091217 lb
-3 40 23 20.5 43 1 0 0 0 0.091217 lb
-3 40 22.5 20.5 42 1 0 0 0 0.091217 lb
-3 40 2.5 40.5 2 41 0 0 0 0.091217 lb
-13 25 10.5 24.5 8 24 0 0 0 0.091217 lb
-13 25 12 27 11 29 0 0 0 0.091217 lb
-3 4 2.5 3 2 2 0 0 0 0.091217 lb
-3 4 4.5 3 6 2 0 0 0 0.091217 lb
-6 25 7 24.5 8 24 0 0 0 0.091217 lb
-6 25 6 24.5 6 24 0 0 0 0.091217 lb
-34 2 33.5 2 33 2 0 0 0 0.091217 lb
-34 2 35 2 36 2 0 0 0 0.091217 lb
-6 8 16 9 26 10 0 0 0 0.091217 lb
-6 8 6 10.5 6 13 0 0 0 0.091217 lb
-6 8 6 7.5 6 7 0 0 0 0.091217 lb
-26 10 27.5 8.5 29 7 0 0 0 0.091217 lb
-26 10 27.5 9 29 8 0 0 0 0.091217 lb
-10 30 10.5 29.5 11 29 0 0 0 0.091217 lb
-8 24 7 23.5 6 23 0 0 0 0.091217 lb
-8 24 8 24.5 8 25 0 0 0 0.091217 lb
-33 2 32.5 2 32 2 0 0 0 0.091217 lb
-29 7 17.5 7 6 7 0 0 0 0.091217 lb
-2 2 1.5 22 1 42 0 0 0 0.091217 lb
-2 2 3.5 2 5 2 0 0 0 0.091217 lb
-21 15 13.5 14.5 6 14 0 0 0 0.091217 lb
-21 15 21 15.5 21 16 0 0 0 0.091217 lb
-1 42 0.5 42.5 0 43 0 0 0 0.091217 lb
-1 42 1.5 41.5 2 41 0 0 0 0.091217 lb
-6 15 6 15.5 6 16 0 0 0 0.091217 lb
-6 15 6 14.5 6 14 0 0 0 0.091217 lb
-43 1 22 0.5 1 0 0 0 0 0.091217 lb
-31 2 18.5 2 6 2 0 0 0 0.091217 lb
-31 2 31.5 2 32 2 0 0 0 0.091217 lb
-6 24 6 23.5 6 23 0 0 0 0.091217 lb
-6 16 6 16.5 6 17 0 0 0 0.091217 lb
-6 23 6 20 6 17 0 0 0 0.091217 lb
-6 2 5.5 2 5 2 0 0 0 0.091217 lb
-6 2 6 4.5 6 7 0 0 0 0.091217 lb
-0 43 0.5 21.5 1 0 0 0 0 0.091217 lb
-1 1 19.5 1.5 38 2 0 0 0 0.091217 lb
-1 1 1 0.5 1 0 0 0 0 0.091217 lb
-2 38 5.5 31.5 9 25 0 0 0 0.091217 lb
-25 13 15.5 13 6 13 0 0 0 0.091217 lb
-25 13 15.5 13.5 6 14 0 0 0 0.091217 lb
-8 25 8.5 25 9 25 0 0 0 0.091217 lb
-11 29 24.5 15.5 38 2 0 0 0 0.091217 lb
-6 17 11.5 18 17 19 0 0 0 0.091217 lb
-16 23 26.5 12.5 37 2 0 0 0 0.091217 lb
-16 23 18.5 19.5 21 16 0 0 0 0.091217 lb
-36 2 36.5 2 37 2 0 0 0 0.091217 lb
-36 2 32.5 5 29 8 0 0 0 0.091217 lb
-6 13 6 13.5 6 14 0 0 0 0.091217 lb
-37 2 37.5 2 38 2 0 0 0 0.091217 lb
-21 16 19 17.5 17 19 0 0 0 0.091217 lb
-grestore
-%Nodes:
-gsave
-29 8 0.304556 1 1 1 nc
-2 41 0.304556 1 1 1 nc
-6 7 0.304556 1 1 1 nc
-5 2 0.304556 1 1 1 nc
-17 19 0.304556 1 1 1 nc
-21 16 0.304556 1 1 1 nc
-1 0 0.304556 1 1 1 nc
-9 25 0.304556 1 1 1 nc
-6 14 0.304556 1 1 1 nc
-42 1 0.304556 1 1 1 nc
-38 2 0.304556 1 1 1 nc
-37 2 0.304556 1 1 1 nc
-6 13 0.304556 1 1 1 nc
-36 2 0.304556 1 1 1 nc
-16 23 0.304556 1 1 1 nc
-6 17 0.304556 1 1 1 nc
-11 29 0.304556 1 1 1 nc
-8 25 0.304556 1 1 1 nc
-32 2 0.304556 1 1 1 nc
-25 13 0.304556 1 1 1 nc
-2 38 0.304556 1 1 1 nc
-1 1 0.304556 1 1 1 nc
-0 43 0.304556 1 1 1 nc
-6 2 0.304556 1 1 1 nc
-6 23 0.304556 1 1 1 nc
-6 16 0.304556 1 1 1 nc
-6 24 0.304556 1 1 1 nc
-31 2 0.304556 1 1 1 nc
-43 1 0.304556 1 1 1 nc
-6 15 0.304556 1 1 1 nc
-1 42 0.304556 1 1 1 nc
-21 15 0.304556 1 1 1 nc
-2 2 0.304556 1 1 1 nc
-29 7 0.304556 1 1 1 nc
-33 2 0.304556 1 1 1 nc
-8 24 0.304556 1 1 1 nc
-10 30 0.304556 1 1 1 nc
-26 10 0.304556 1 1 1 nc
-6 8 0.304556 1 1 1 nc
-34 2 0.304556 1 1 1 nc
-6 25 0.304556 1 1 1 nc
-3 4 0.304556 1 1 1 nc
-13 25 0.304556 1 1 1 nc
-3 40 0.304556 1 1 1 nc
-9 31 0.304556 1 1 1 nc
-grestore
-grestore
-showpage
Index: doc/mainpage.dox.in
===================================================================
--- doc/mainpage.dox.in	(revision 930)
+++ doc/mainpage.dox.in	(revision 929)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -22,9 +22,12 @@
 \section intro Introduction
 
-<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
-and <b>O</b>ptimization in <b>N</b>etworks</i>.
-It is a C++ template library providing efficient implementations of common
-data structures and algorithms with focus on combinatorial optimization
-tasks connected mainly with graphs and networks.
+\subsection whatis What is LEMON
+
+LEMON stands for <b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling
+and <b>O</b>ptimization in <b>N</b>etworks.
+It is a C++ template
+library aimed at combinatorial optimization tasks which
+often involve in working
+with graphs.
 
 <b>
@@ -36,21 +39,8 @@
 </b>
 
-The project is maintained by the
-<a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on
-Combinatorial Optimization</a> \ref egres
-at the Operations Research Department of the
-<a href="http://www.elte.hu/en/">E&ouml;tv&ouml;s Lor&aacute;nd University</a>,
-Budapest, Hungary.
-LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>
-initiative \ref coinor.
-
-\section howtoread How to Read the Documentation
+\subsection howtoread How to read the documentation
 
 If you would like to get to know the library, see
 <a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.
-
-If you are interested in starting to use the library, see the <a class="el"
-href="http://lemon.cs.elte.hu/trac/lemon/wiki/InstallGuide/">Installation
-Guide</a>.
 
 If you know what you are looking for, then try to find it under the
Index: doc/min_cost_flow.dox
===================================================================
--- doc/min_cost_flow.dox	(revision 877)
+++ doc/min_cost_flow.dox	(revision 663)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,5 @@
 minimum total cost from a set of supply nodes to a set of demand nodes
 in a network with capacity constraints (lower and upper bounds)
-and arc costs \ref amo93networkflows.
+and arc costs.
 
 Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,
@@ -79,8 +79,8 @@
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
-   - \f$\pi(u)\leq 0\f$;
+   - \f$\pi(u)<=0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
-
+ 
 Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc
 \f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e.
@@ -120,5 +120,5 @@
 \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]
 
-It means that the total demand must be less or equal to the
+It means that the total demand must be less or equal to the 
 total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or
 positive) and all the demands have to be satisfied, but there
@@ -146,5 +146,5 @@
    - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.
  - For all \f$u\in V\f$ nodes:
-   - \f$\pi(u)\geq 0\f$;
+   - \f$\pi(u)>=0\f$;
    - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,
      then \f$\pi(u)=0\f$.
Index: c/references.bib
===================================================================
--- doc/references.bib	(revision 904)
+++ 	(revision )
@@ -1,314 +1,0 @@
-%%%%% Defining LEMON %%%%%
-
-@misc{lemon,
-  key =          {LEMON},
-  title =        {{LEMON} -- {L}ibrary for {E}fficient {M}odeling and
-                  {O}ptimization in {N}etworks},
-  howpublished = {\url{http://lemon.cs.elte.hu/}},
-  year =         2009
-}
-
-@misc{egres,
-  key =          {EGRES},
-  title =        {{EGRES} -- {E}gerv{\'a}ry {R}esearch {G}roup on
-                  {C}ombinatorial {O}ptimization},
-  url =          {http://www.cs.elte.hu/egres/}
-}
-
-@misc{coinor,
-  key =          {COIN-OR},
-  title =        {{COIN-OR} -- {C}omputational {I}nfrastructure for
-                  {O}perations {R}esearch},
-  url =          {http://www.coin-or.org/}
-}
-
-
-%%%%% Other libraries %%%%%%
-
-@misc{boost,
-  key =          {Boost},
-  title =        {{B}oost {C++} {L}ibraries},
-  url =          {http://www.boost.org/}
-}
-
-@book{bglbook,
-  author =       {Jeremy G. Siek and Lee-Quan Lee and Andrew
-                  Lumsdaine},
-  title =        {The Boost Graph Library: User Guide and Reference
-                  Manual},
-  publisher =    {Addison-Wesley},
-  year =         2002
-}
-
-@misc{leda,
-  key =          {LEDA},
-  title =        {{LEDA} -- {L}ibrary of {E}fficient {D}ata {T}ypes and
-                  {A}lgorithms},
-  url =          {http://www.algorithmic-solutions.com/}
-}
-
-@book{ledabook,
-  author =       {Kurt Mehlhorn and Stefan N{\"a}her},
-  title =        {{LEDA}: {A} platform for combinatorial and geometric
-                  computing},
-  isbn =         {0-521-56329-1},
-  publisher =    {Cambridge University Press},
-  address =      {New York, NY, USA},
-  year =         1999
-}
-
-
-%%%%% Tools that LEMON depends on %%%%%
-
-@misc{cmake,
-  key =          {CMake},
-  title =        {{CMake} -- {C}ross {P}latform {M}ake},
-  url =          {http://www.cmake.org/}
-}
-
-@misc{doxygen,
-  key =          {Doxygen},
-  title =        {{Doxygen} -- {S}ource code documentation generator
-                  tool},
-  url =          {http://www.doxygen.org/}
-}
-
-
-%%%%% LP/MIP libraries %%%%%
-
-@misc{glpk,
-  key =          {GLPK},
-  title =        {{GLPK} -- {GNU} {L}inear {P}rogramming {K}it},
-  url =          {http://www.gnu.org/software/glpk/}
-}
-
-@misc{clp,
-  key =          {Clp},
-  title =        {{Clp} -- {Coin-Or} {L}inear {P}rogramming},
-  url =          {http://projects.coin-or.org/Clp/}
-}
-
-@misc{cbc,
-  key =          {Cbc},
-  title =        {{Cbc} -- {Coin-Or} {B}ranch and {C}ut},
-  url =          {http://projects.coin-or.org/Cbc/}
-}
-
-@misc{cplex,
-  key =          {CPLEX},
-  title =        {{ILOG} {CPLEX}},
-  url =          {http://www.ilog.com/}
-}
-
-@misc{soplex,
-  key =          {SoPlex},
-  title =        {{SoPlex} -- {T}he {S}equential {O}bject-{O}riented
-                  {S}implex},
-  url =          {http://soplex.zib.de/}
-}
-
-
-%%%%% General books %%%%%
-
-@book{amo93networkflows,
-  author =       {Ravindra K. Ahuja and Thomas L. Magnanti and James
-                  B. Orlin},
-  title =        {Network Flows: Theory, Algorithms, and Applications},
-  publisher =    {Prentice-Hall, Inc.},
-  year =         1993,
-  month =        feb,
-  isbn =         {978-0136175490}
-}
-
-@book{schrijver03combinatorial,
-  author =       {Alexander Schrijver},
-  title =        {Combinatorial Optimization: Polyhedra and Efficiency},
-  publisher =    {Springer-Verlag},
-  year =         2003,
-  isbn =         {978-3540443896}
-}
-
-@book{clrs01algorithms,
-  author =       {Thomas H. Cormen and Charles E. Leiserson and Ronald
-                  L. Rivest and Clifford Stein},
-  title =        {Introduction to Algorithms},
-  publisher =    {The MIT Press},
-  year =         2001,
-  edition =      {2nd}
-}
-
-@book{stroustrup00cpp,
-  author =       {Bjarne Stroustrup},
-  title =        {The C++ Programming Language},
-  edition =      {3rd},
-  publisher =    {Addison-Wesley Professional},
-  isbn =         0201700735,
-  month =        {February},
-  year =         2000
-}
-
-
-%%%%% Maximum flow algorithms %%%%%
-
-@article{edmondskarp72theoretical,
-  author =       {Jack Edmonds and Richard M. Karp},
-  title =        {Theoretical improvements in algorithmic efficiency
-                  for network flow problems},
-  journal =      {Journal of the ACM},
-  year =         1972,
-  volume =       19,
-  number =       2,
-  pages =        {248-264}
-}
-
-@article{goldberg88newapproach,
-  author =       {Andrew V. Goldberg and Robert E. Tarjan},
-  title =        {A new approach to the maximum flow problem},
-  journal =      {Journal of the ACM},
-  year =         1988,
-  volume =       35,
-  number =       4,
-  pages =        {921-940}
-}
-
-@article{dinic70algorithm,
-  author =       {E. A. Dinic},
-  title =        {Algorithm for solution of a problem of maximum flow
-                  in a network with power estimation},
-  journal =      {Soviet Math. Doklady},
-  year =         1970,
-  volume =       11,
-  pages =        {1277-1280}
-}
-
-@article{goldberg08partial,
-  author =       {Andrew V. Goldberg},
-  title =        {The Partial Augment-Relabel Algorithm for the
-                  Maximum Flow Problem},
-  journal =      {16th Annual European Symposium on Algorithms},
-  year =         2008,
-  pages =        {466-477}
-}
-
-@article{sleator83dynamic,
-  author =       {Daniel D. Sleator and Robert E. Tarjan},
-  title =        {A data structure for dynamic trees},
-  journal =      {Journal of Computer and System Sciences},
-  year =         1983,
-  volume =       26,
-  number =       3,
-  pages =        {362-391}
-}
-
-
-%%%%% Minimum mean cycle algorithms %%%%%
-
-@article{karp78characterization,
-  author =       {Richard M. Karp},
-  title =        {A characterization of the minimum cycle mean in a
-                  digraph},
-  journal =      {Discrete Math.},
-  year =         1978,
-  volume =       23,
-  pages =        {309-311}
-}
-
-@article{dasdan98minmeancycle,
-  author =       {Ali Dasdan and Rajesh K. Gupta},
-  title =        {Faster Maximum and Minimum Mean Cycle Alogrithms for
-                  System Performance Analysis},
-  journal =      {IEEE Transactions on Computer-Aided Design of
-                  Integrated Circuits and Systems},
-  year =         1998,
-  volume =       17,
-  number =       10,
-  pages =        {889-899}
-}
-
-
-%%%%% Minimum cost flow algorithms %%%%%
-
-@article{klein67primal,
-  author =       {Morton Klein},
-  title =        {A primal method for minimal cost flows with
-                  applications to the assignment and transportation
-                  problems},
-  journal =      {Management Science},
-  year =         1967,
-  volume =       14,
-  pages =        {205-220}
-}
-
-@article{goldberg89cyclecanceling,
-  author =       {Andrew V. Goldberg and Robert E. Tarjan},
-  title =        {Finding minimum-cost circulations by canceling
-                  negative cycles},
-  journal =      {Journal of the ACM},
-  year =         1989,
-  volume =       36,
-  number =       4,
-  pages =        {873-886}
-}
-
-@article{goldberg90approximation,
-  author =       {Andrew V. Goldberg and Robert E. Tarjan},
-  title =        {Finding Minimum-Cost Circulations by Successive
-                  Approximation},
-  journal =      {Mathematics of Operations Research},
-  year =         1990,
-  volume =       15,
-  number =       3,
-  pages =        {430-466}
-}
-
-@article{goldberg97efficient,
-  author =       {Andrew V. Goldberg},
-  title =        {An Efficient Implementation of a Scaling
-                  Minimum-Cost Flow Algorithm},
-  journal =      {Journal of Algorithms},
-  year =         1997,
-  volume =       22,
-  number =       1,
-  pages =        {1-29}
-}
-
-@article{bunnagel98efficient,
-  author =       {Ursula B{\"u}nnagel and Bernhard Korte and Jens
-                  Vygen},
-  title =        {Efficient implementation of the {G}oldberg-{T}arjan
-                  minimum-cost flow algorithm},
-  journal =      {Optimization Methods and Software},
-  year =         1998,
-  volume =       10,
-  pages =        {157-174}
-}
-
-@book{dantzig63linearprog,
-  author =       {George B. Dantzig},
-  title =        {Linear Programming and Extensions},
-  publisher =    {Princeton University Press},
-  year =         1963
-}
-
-@mastersthesis{kellyoneill91netsimplex,
-  author =       {Damian J. Kelly and Garrett M. O'Neill},
-  title =        {The Minimum Cost Flow Problem and The Network
-                  Simplex Method},
-  school =       {University College},
-  address =      {Dublin, Ireland},
-  year =         1991,
-  month =        sep
-}
-
-%%%%% Other algorithms %%%%%
-
-@article{grosso08maxclique,
-  author =       {Andrea Grosso and Marco Locatelli and Wayne Pullan},
-  title =        {Simple ingredients leading to very efficient
-                  heuristics for the maximum clique problem},
-  journal =      {Journal of Heuristics},
-  year =         2008,
-  volume =       14,
-  number =       6,
-  pages =        {587--612}
-}
Index: lemon/CMakeLists.txt
===================================================================
--- lemon/CMakeLists.txt	(revision 981)
+++ lemon/CMakeLists.txt	(revision 968)
@@ -5,10 +5,10 @@
 
 CONFIGURE_FILE(
-  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.in
+  ${CMAKE_CURRENT_SOURCE_DIR}/config.h.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/config.h
 )
 
 CONFIGURE_FILE(
-  ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.in
+  ${CMAKE_CURRENT_SOURCE_DIR}/lemon.pc.cmake
   ${CMAKE_CURRENT_BINARY_DIR}/lemon.pc
   @ONLY
Index: lemon/Makefile.am
===================================================================
--- lemon/Makefile.am	(revision 963)
+++ lemon/Makefile.am	(revision 963)
@@ -0,0 +1,137 @@
+EXTRA_DIST += \
+	lemon/lemon.pc.in \
+	lemon/lemon.pc.cmake \
+	lemon/CMakeLists.txt \
+	lemon/config.h.cmake
+
+pkgconfig_DATA += lemon/lemon.pc
+
+lib_LTLIBRARIES += lemon/libemon.la
+
+lemon_libemon_la_SOURCES = \
+	lemon/arg_parser.cc \
+	lemon/base.cc \
+	lemon/color.cc \
+	lemon/lp_base.cc \
+	lemon/lp_skeleton.cc \
+	lemon/random.cc \
+	lemon/bits/windows.cc
+
+nodist_lemon_HEADERS = lemon/config.h	
+
+lemon_libemon_la_CXXFLAGS = \
+	$(AM_CXXFLAGS) \
+	$(GLPK_CFLAGS) \
+	$(CPLEX_CFLAGS) \
+	$(SOPLEX_CXXFLAGS) \
+	$(CLP_CXXFLAGS) \
+	$(CBC_CXXFLAGS)
+
+lemon_libemon_la_LDFLAGS = \
+	$(GLPK_LIBS) \
+	$(CPLEX_LIBS) \
+	$(SOPLEX_LIBS) \
+	$(CLP_LIBS) \
+	$(CBC_LIBS)
+
+if HAVE_GLPK
+lemon_libemon_la_SOURCES += lemon/glpk.cc
+endif
+
+if HAVE_CPLEX
+lemon_libemon_la_SOURCES += lemon/cplex.cc
+endif
+
+if HAVE_SOPLEX
+lemon_libemon_la_SOURCES += lemon/soplex.cc
+endif
+
+if HAVE_CLP
+lemon_libemon_la_SOURCES += lemon/clp.cc
+endif
+
+if HAVE_CBC
+lemon_libemon_la_SOURCES += lemon/cbc.cc
+endif
+
+lemon_HEADERS += \
+	lemon/adaptors.h \
+	lemon/arg_parser.h \
+	lemon/assert.h \
+	lemon/bfs.h \
+	lemon/bin_heap.h \
+	lemon/bucket_heap.h \
+	lemon/cbc.h \
+	lemon/circulation.h \
+	lemon/clp.h \
+	lemon/color.h \
+	lemon/concept_check.h \
+	lemon/connectivity.h \
+	lemon/counter.h \
+	lemon/core.h \
+	lemon/cplex.h \
+	lemon/dfs.h \
+	lemon/dijkstra.h \
+	lemon/dim2.h \
+	lemon/dimacs.h \
+	lemon/edge_set.h \
+	lemon/elevator.h \
+	lemon/error.h \
+	lemon/euler.h \
+	lemon/fib_heap.h \
+	lemon/full_graph.h \
+	lemon/glpk.h \
+	lemon/gomory_hu.h \
+	lemon/graph_to_eps.h \
+	lemon/grid_graph.h \
+	lemon/hypercube_graph.h \
+	lemon/kruskal.h \
+	lemon/hao_orlin.h \
+	lemon/lgf_reader.h \
+	lemon/lgf_writer.h \
+	lemon/list_graph.h \
+	lemon/lp.h \
+	lemon/lp_base.h \
+	lemon/lp_skeleton.h \
+	lemon/maps.h \
+	lemon/matching.h \
+	lemon/math.h \
+	lemon/min_cost_arborescence.h \
+	lemon/nauty_reader.h \
+	lemon/network_simplex.h \
+	lemon/path.h \
+	lemon/preflow.h \
+	lemon/radix_heap.h \
+	lemon/radix_sort.h \
+	lemon/random.h \
+	lemon/smart_graph.h \
+	lemon/soplex.h \
+	lemon/suurballe.h \
+	lemon/time_measure.h \
+	lemon/tolerance.h \
+	lemon/unionfind.h \
+	lemon/bits/windows.h
+
+bits_HEADERS += \
+	lemon/bits/alteration_notifier.h \
+	lemon/bits/array_map.h \
+	lemon/bits/bezier.h \
+	lemon/bits/default_map.h \
+	lemon/bits/edge_set_extender.h \
+	lemon/bits/enable_if.h \
+	lemon/bits/graph_adaptor_extender.h \
+	lemon/bits/graph_extender.h \
+	lemon/bits/map_extender.h \
+	lemon/bits/path_dump.h \
+	lemon/bits/solver_bits.h \
+	lemon/bits/traits.h \
+	lemon/bits/variant.h \
+	lemon/bits/vector_map.h
+
+concept_HEADERS += \
+	lemon/concepts/digraph.h \
+	lemon/concepts/graph.h \
+	lemon/concepts/graph_components.h \
+	lemon/concepts/heap.h \
+	lemon/concepts/maps.h \
+	lemon/concepts/path.h
Index: lemon/adaptors.h
===================================================================
--- lemon/adaptors.h	(revision 877)
+++ lemon/adaptors.h	(revision 656)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -361,7 +361,4 @@
   /// parameter is set to be \c const.
   ///
-  /// This class provides item counting in the same time as the adapted
-  /// digraph structure.
-  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
@@ -422,5 +419,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -509,9 +506,9 @@
 
     template <typename V>
-    class NodeMap
-      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
+    class NodeMap 
+      : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>, 
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-        LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
+	LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
     public:
@@ -536,7 +533,7 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
-              LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
+	      LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
       typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, ch>,
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> Parent;
@@ -583,5 +580,5 @@
       Parent::initialize(digraph);
       _node_filter = &node_filter;
-      _arc_filter = &arc_filter;
+      _arc_filter = &arc_filter;      
     }
 
@@ -652,8 +649,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
+      typedef SubMapExtender<SubDigraphBase<DGR, NF, AF, false>, 
         LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, NodeMap<V>)> Parent;
 
@@ -679,5 +676,5 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubDigraphBase<DGR, NF, AF, false>,
           LEMON_SCOPE_FIX(DigraphAdaptorBase<DGR>, ArcMap<V>)> {
@@ -722,6 +719,4 @@
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
@@ -1022,8 +1017,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1049,8 +1044,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1076,8 +1071,8 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, ch>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
@@ -1118,6 +1113,6 @@
     NF* _node_filter;
     EF* _edge_filter;
-    SubGraphBase()
-          : Parent(), _node_filter(0), _edge_filter(0) { }
+    SubGraphBase() 
+	  : Parent(), _node_filter(0), _edge_filter(0) { }
 
     void initialize(GR& graph, NF& node_filter, EF& edge_filter) {
@@ -1220,8 +1215,8 @@
 
     template <typename V>
-    class NodeMap
+    class NodeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, NodeMap<V>)> Parent;
 
@@ -1247,8 +1242,8 @@
 
     template <typename V>
-    class ArcMap
+    class ArcMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
           LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, ArcMap<V>)> Parent;
 
@@ -1274,9 +1269,9 @@
 
     template <typename V>
-    class EdgeMap
+    class EdgeMap 
       : public SubMapExtender<SubGraphBase<GR, NF, EF, false>,
         LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> {
-      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>,
-        LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
+      typedef SubMapExtender<SubGraphBase<GR, NF, EF, false>, 
+	LEMON_SCOPE_FIX(GraphAdaptorBase<GR>, EdgeMap<V>)> Parent;
 
     public:
@@ -1319,6 +1314,4 @@
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes, edges and arcs.
   ///
   /// \tparam GR The type of the adapted graph.
@@ -1478,6 +1471,4 @@
   /// by adding or removing nodes or arcs/edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time item counting.
   ///
   /// \tparam GR The type of the adapted digraph or graph.
@@ -1505,5 +1496,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >,
+      SubDigraphBase<GR, NF, ConstMap<typename GR::Arc, Const<bool, true> >, 
                      true> > Parent;
 
@@ -1526,5 +1517,5 @@
     /// Creates a subgraph for the given digraph or graph with the
     /// given node filter map.
-    FilterNodes(GR& graph, NF& node_filter)
+    FilterNodes(GR& graph, NF& node_filter) 
       : Parent(), const_true_map()
     {
@@ -1564,9 +1555,9 @@
                     typename enable_if<UndirectedTagIndicator<GR> >::type> :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > {
 
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >,
+      SubGraphBase<GR, NF, ConstMap<typename GR::Edge, Const<bool, true> >, 
                    true> > Parent;
 
@@ -1628,6 +1619,4 @@
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes and arcs.
   ///
   /// \tparam DGR The type of the adapted digraph.
@@ -1654,5 +1643,5 @@
 #endif
     typedef DigraphAdaptorExtender<
-      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >,
+      SubDigraphBase<DGR, ConstMap<typename DGR::Node, Const<bool, true> >, 
                      AF, false> > Parent;
 
@@ -1740,6 +1729,4 @@
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides only linear time counting for nodes, edges and arcs.
   ///
   /// \tparam GR The type of the adapted graph.
@@ -1762,9 +1749,9 @@
   class FilterEdges :
     public GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true> >, 
                    EF, false> > {
 #endif
     typedef GraphAdaptorExtender<
-      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >,
+      SubGraphBase<GR, ConstMap<typename GR::Node, Const<bool, true > >, 
                    EF, false> > Parent;
 
@@ -1791,5 +1778,5 @@
     /// Creates a subgraph for the given graph with the given edge
     /// filter map.
-    FilterEdges(GR& graph, EF& edge_filter)
+    FilterEdges(GR& graph, EF& edge_filter) 
       : Parent(), const_true_map() {
       Parent::initialize(graph, const_true_map, edge_filter);
@@ -1859,5 +1846,5 @@
       bool _forward;
 
-      Arc(const Edge& edge, bool forward)
+      Arc(const Edge& edge, bool forward) 
         : _edge(edge), _forward(forward) {}
 
@@ -2099,5 +2086,5 @@
 
       ArcMapBase(const UndirectorBase<DGR>& adaptor, const V& value)
-        : _forward(*adaptor._digraph, value),
+        : _forward(*adaptor._digraph, value), 
           _backward(*adaptor._digraph, value) {}
 
@@ -2217,5 +2204,5 @@
     typedef typename ItemSetTraits<DGR, Edge>::ItemNotifier EdgeNotifier;
     EdgeNotifier& notifier(Edge) const { return _digraph->notifier(Edge()); }
-
+    
     typedef EdgeNotifier ArcNotifier;
     ArcNotifier& notifier(Arc) const { return _digraph->notifier(Edge()); }
@@ -2245,7 +2232,4 @@
   /// by adding or removing nodes or edges, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides item counting in the same time as the adapted
-  /// digraph structure.
   ///
   /// \tparam DGR The type of the adapted digraph.
@@ -2551,7 +2535,4 @@
   /// by adding or removing nodes or arcs, unless the \c GR template
   /// parameter is set to be \c const.
-  ///
-  /// This class provides item counting in the same time as the adapted
-  /// graph structure.
   ///
   /// \tparam GR The type of the adapted graph.
@@ -2698,6 +2679,4 @@
   /// This class conforms to the \ref concepts::Digraph "Digraph" concept.
   ///
-  /// This class provides only linear time counting for nodes and arcs.
-  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
@@ -2729,5 +2708,5 @@
            typename FM = CM,
            typename TL = Tolerance<typename CM::Value> >
-  class ResidualDigraph
+  class ResidualDigraph 
     : public SubDigraph<
         Undirector<const DGR>,
@@ -2786,5 +2765,5 @@
     ResidualDigraph(const DGR& digraph, const CM& capacity,
                     FM& flow, const TL& tolerance = Tolerance())
-      : Parent(), _capacity(&capacity), _flow(&flow),
+      : Parent(), _capacity(&capacity), _flow(&flow), 
         _graph(digraph), _node_filter(),
         _forward_filter(capacity, flow, tolerance),
@@ -2868,5 +2847,5 @@
 
       /// Constructor
-      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor)
+      ResidualCapacity(const ResidualDigraph<DGR, CM, FM, TL>& adaptor) 
         : _adaptor(&adaptor) {}
 
@@ -3347,7 +3326,4 @@
   /// in the adaptor.
   ///
-  /// This class provides item counting in the same time as the adapted
-  /// digraph structure.
-  ///
   /// \tparam DGR The type of the adapted digraph.
   /// It must conform to the \ref concepts::Digraph "Digraph" concept.
@@ -3448,5 +3424,5 @@
     /// to get a node map of the split digraph.
     /// Its value type is inherited from the first node map type (\c IN).
-    /// \tparam IN The type of the node map for the in-nodes.
+    /// \tparam IN The type of the node map for the in-nodes. 
     /// \tparam OUT The type of the node map for the out-nodes.
     template <typename IN, typename OUT>
Index: lemon/arg_parser.cc
===================================================================
--- lemon/arg_parser.cc	(revision 877)
+++ lemon/arg_parser.cc	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -21,21 +21,12 @@
 namespace lemon {
 
-  void ArgParser::_terminate(ArgParserException::Reason reason) const
-  {
-    if(_exit_on_problems)
-      exit(1);
-    else throw(ArgParserException(reason));
-  }
-
-
   void ArgParser::_showHelp(void *p)
   {
     (static_cast<ArgParser*>(p))->showHelp();
-    (static_cast<ArgParser*>(p))->_terminate(ArgParserException::HELP);
+    exit(1);
   }
 
   ArgParser::ArgParser(int argc, const char * const *argv)
-    :_argc(argc), _argv(argv), _command_name(argv[0]),
-    _exit_on_problems(true) {
+    :_argc(argc), _argv(argv), _command_name(argv[0]) {
     funcOption("-help","Print a short help message",_showHelp,this);
     synonym("help","-help");
@@ -352,5 +343,5 @@
         i!=_others_help.end();++i) showHelp(i);
     for(Opts::const_iterator i=_opts.begin();i!=_opts.end();++i) showHelp(i);
-    _terminate(ArgParserException::HELP);
+    exit(1);
   }
 
@@ -361,5 +352,5 @@
     std::cerr << "\nType '" << _command_name <<
       " --help' to obtain a short summary on the usage.\n\n";
-    _terminate(ArgParserException::UNKNOWN_OPT);
+    exit(1);
   }
 
@@ -424,5 +415,5 @@
       std::cerr << "\nType '" << _command_name <<
         " --help' to obtain a short summary on the usage.\n\n";
-      _terminate(ArgParserException::INVALID_OPT);
+      exit(1);
     }
   }
Index: lemon/arg_parser.h
===================================================================
--- lemon/arg_parser.h	(revision 879)
+++ lemon/arg_parser.h	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -34,49 +34,4 @@
 
 namespace lemon {
-
-  ///Exception used by ArgParser
-
-  ///Exception used by ArgParser.
-  ///
-  class ArgParserException : public Exception {
-  public:
-    /// Reasons for failure
-
-    /// Reasons for failure.
-    ///
-    enum Reason {
-      HELP,         ///< <tt>--help</tt> option was given.
-      UNKNOWN_OPT,  ///< Unknown option was given.
-      INVALID_OPT   ///< Invalid combination of options.
-    };
-
-  private:
-    Reason _reason;
-
-  public:
-    ///Constructor
-    ArgParserException(Reason r) throw() : _reason(r) {}
-    ///Virtual destructor
-    virtual ~ArgParserException() throw() {}
-    ///A short description of the exception
-    virtual const char* what() const throw() {
-      switch(_reason)
-        {
-        case HELP:
-          return "lemon::ArgParseException: ask for help";
-          break;
-        case UNKNOWN_OPT:
-          return "lemon::ArgParseException: unknown option";
-          break;
-        case INVALID_OPT:
-          return "lemon::ArgParseException: invalid combination of options";
-          break;
-        }
-      return "";
-    }
-    ///Return the reason for the failure
-    Reason reason() const {return _reason; }
-  };
-
 
   ///Command line arguments parser
@@ -162,8 +117,4 @@
                     void (*func)(void *),void *data);
 
-    bool _exit_on_problems;
-
-    void _terminate(ArgParserException::Reason reason) const;
-
   public:
 
@@ -430,9 +381,4 @@
     const std::vector<std::string> &files() const { return _file_args; }
 
-    ///Throw instead of exit in case of problems
-    void throwOnProblems()
-    {
-      _exit_on_problems=false;
-    }
   };
 }
Index: mon/bellman_ford.h
===================================================================
--- lemon/bellman_ford.h	(revision 880)
+++ 	(revision )
@@ -1,1115 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BELLMAN_FORD_H
-#define LEMON_BELLMAN_FORD_H
-
-/// \ingroup shortest_path
-/// \file
-/// \brief Bellman-Ford algorithm.
-
-#include <lemon/list_graph.h>
-#include <lemon/bits/path_dump.h>
-#include <lemon/core.h>
-#include <lemon/error.h>
-#include <lemon/maps.h>
-#include <lemon/path.h>
-
-#include <limits>
-
-namespace lemon {
-
-  /// \brief Default OperationTraits for the BellmanFord algorithm class.
-  ///
-  /// This operation traits class defines all computational operations
-  /// and constants that are used in the Bellman-Ford algorithm.
-  /// The default implementation is based on the \c numeric_limits class.
-  /// If the numeric type does not have infinity value, then the maximum
-  /// value is used as extremal infinity value.
-  template <
-    typename V,
-    bool has_inf = std::numeric_limits<V>::has_infinity>
-  struct BellmanFordDefaultOperationTraits {
-    /// \e
-    typedef V Value;
-    /// \brief Gives back the zero value of the type.
-    static Value zero() {
-      return static_cast<Value>(0);
-    }
-    /// \brief Gives back the positive infinity value of the type.
-    static Value infinity() {
-      return std::numeric_limits<Value>::infinity();
-    }
-    /// \brief Gives back the sum of the given two elements.
-    static Value plus(const Value& left, const Value& right) {
-      return left + right;
-    }
-    /// \brief Gives back \c true only if the first value is less than
-    /// the second.
-    static bool less(const Value& left, const Value& right) {
-      return left < right;
-    }
-  };
-
-  template <typename V>
-  struct BellmanFordDefaultOperationTraits<V, false> {
-    typedef V Value;
-    static Value zero() {
-      return static_cast<Value>(0);
-    }
-    static Value infinity() {
-      return std::numeric_limits<Value>::max();
-    }
-    static Value plus(const Value& left, const Value& right) {
-      if (left == infinity() || right == infinity()) return infinity();
-      return left + right;
-    }
-    static bool less(const Value& left, const Value& right) {
-      return left < right;
-    }
-  };
-
-  /// \brief Default traits class of BellmanFord class.
-  ///
-  /// Default traits class of BellmanFord class.
-  /// \param GR The type of the digraph.
-  /// \param LEN The type of the length map.
-  template<typename GR, typename LEN>
-  struct BellmanFordDefaultTraits {
-    /// The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \brief The type of the map that stores the arc lengths.
-    ///
-    /// The type of the map that stores the arc lengths.
-    /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LEN LengthMap;
-
-    /// The type of the arc lengths.
-    typedef typename LEN::Value Value;
-
-    /// \brief Operation traits for Bellman-Ford algorithm.
-    ///
-    /// It defines the used operations and the infinity value for the
-    /// given \c Value type.
-    /// \see BellmanFordDefaultOperationTraits
-    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
-
-    /// \brief The type of the map that stores the last arcs of the
-    /// shortest paths.
-    ///
-    /// The type of the map that stores the last
-    /// arcs of the shortest paths.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
-
-    /// \brief Instantiates a \c PredMap.
-    ///
-    /// This function instantiates a \ref PredMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref PredMap.
-    static PredMap *createPredMap(const GR& g) {
-      return new PredMap(g);
-    }
-
-    /// \brief The type of the map that stores the distances of the nodes.
-    ///
-    /// The type of the map that stores the distances of the nodes.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<typename LEN::Value> DistMap;
-
-    /// \brief Instantiates a \c DistMap.
-    ///
-    /// This function instantiates a \ref DistMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref DistMap.
-    static DistMap *createDistMap(const GR& g) {
-      return new DistMap(g);
-    }
-
-  };
-
-  /// \brief %BellmanFord algorithm class.
-  ///
-  /// \ingroup shortest_path
-  /// This class provides an efficient implementation of the Bellman-Ford
-  /// algorithm. The maximum time complexity of the algorithm is
-  /// <tt>O(ne)</tt>.
-  ///
-  /// The Bellman-Ford algorithm solves the single-source shortest path
-  /// problem when the arcs can have negative lengths, but the digraph
-  /// should not contain directed cycles with negative total length.
-  /// If all arc costs are non-negative, consider to use the Dijkstra
-  /// algorithm instead, since it is more efficient.
-  ///
-  /// The arc lengths are passed to the algorithm using a
-  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any
-  /// kind of length. The type of the length values is determined by the
-  /// \ref concepts::ReadMap::Value "Value" type of the length map.
-  ///
-  /// There is also a \ref bellmanFord() "function-type interface" for the
-  /// Bellman-Ford algorithm, which is convenient in the simplier cases and
-  /// it can be used easier.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// The default type is \ref ListDigraph.
-  /// \tparam LEN A \ref concepts::ReadMap "readable" arc map that specifies
-  /// the lengths of the arcs. The default map type is
-  /// \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref BellmanFordDefaultTraits
-  /// "BellmanFordDefaultTraits<GR, LEN>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
-#else
-  template <typename GR=ListDigraph,
-            typename LEN=typename GR::template ArcMap<int>,
-            typename TR=BellmanFordDefaultTraits<GR,LEN> >
-#endif
-  class BellmanFord {
-  public:
-
-    ///The type of the underlying digraph.
-    typedef typename TR::Digraph Digraph;
-
-    /// \brief The type of the arc lengths.
-    typedef typename TR::LengthMap::Value Value;
-    /// \brief The type of the map that stores the arc lengths.
-    typedef typename TR::LengthMap LengthMap;
-    /// \brief The type of the map that stores the last
-    /// arcs of the shortest paths.
-    typedef typename TR::PredMap PredMap;
-    /// \brief The type of the map that stores the distances of the nodes.
-    typedef typename TR::DistMap DistMap;
-    /// The type of the paths.
-    typedef PredMapPath<Digraph, PredMap> Path;
-    ///\brief The \ref BellmanFordDefaultOperationTraits
-    /// "operation traits class" of the algorithm.
-    typedef typename TR::OperationTraits OperationTraits;
-
-    ///The \ref BellmanFordDefaultTraits "traits class" of the algorithm.
-    typedef TR Traits;
-
-  private:
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::OutArcIt OutArcIt;
-
-    // Pointer to the underlying digraph.
-    const Digraph *_gr;
-    // Pointer to the length map
-    const LengthMap *_length;
-    // Pointer to the map of predecessors arcs.
-    PredMap *_pred;
-    // Indicates if _pred is locally allocated (true) or not.
-    bool _local_pred;
-    // Pointer to the map of distances.
-    DistMap *_dist;
-    // Indicates if _dist is locally allocated (true) or not.
-    bool _local_dist;
-
-    typedef typename Digraph::template NodeMap<bool> MaskMap;
-    MaskMap *_mask;
-
-    std::vector<Node> _process;
-
-    // Creates the maps if necessary.
-    void create_maps() {
-      if(!_pred) {
-        _local_pred = true;
-        _pred = Traits::createPredMap(*_gr);
-      }
-      if(!_dist) {
-        _local_dist = true;
-        _dist = Traits::createDistMap(*_gr);
-      }
-      if(!_mask) {
-        _mask = new MaskMap(*_gr);
-      }
-    }
-
-  public :
-
-    typedef BellmanFord Create;
-
-    /// \name Named Template Parameters
-
-    ///@{
-
-    template <class T>
-    struct SetPredMapTraits : public Traits {
-      typedef T PredMap;
-      static PredMap *createPredMap(const Digraph&) {
-        LEMON_ASSERT(false, "PredMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c PredMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c PredMap type.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    template <class T>
-    struct SetPredMap
-      : public BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > {
-      typedef BellmanFord< Digraph, LengthMap, SetPredMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct SetDistMapTraits : public Traits {
-      typedef T DistMap;
-      static DistMap *createDistMap(const Digraph&) {
-        LEMON_ASSERT(false, "DistMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c DistMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c DistMap type.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    template <class T>
-    struct SetDistMap
-      : public BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > {
-      typedef BellmanFord< Digraph, LengthMap, SetDistMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct SetOperationTraitsTraits : public Traits {
-      typedef T OperationTraits;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c OperationTraits type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c OperationTraits type.
-    /// For more information, see \ref BellmanFordDefaultOperationTraits.
-    template <class T>
-    struct SetOperationTraits
-      : public BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> > {
-      typedef BellmanFord< Digraph, LengthMap, SetOperationTraitsTraits<T> >
-      Create;
-    };
-
-    ///@}
-
-  protected:
-
-    BellmanFord() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param g The digraph the algorithm runs on.
-    /// \param length The length map used by the algorithm.
-    BellmanFord(const Digraph& g, const LengthMap& length) :
-      _gr(&g), _length(&length),
-      _pred(0), _local_pred(false),
-      _dist(0), _local_dist(false), _mask(0) {}
-
-    ///Destructor.
-    ~BellmanFord() {
-      if(_local_pred) delete _pred;
-      if(_local_dist) delete _dist;
-      if(_mask) delete _mask;
-    }
-
-    /// \brief Sets the length map.
-    ///
-    /// Sets the length map.
-    /// \return <tt>(*this)</tt>
-    BellmanFord &lengthMap(const LengthMap &map) {
-      _length = &map;
-      return *this;
-    }
-
-    /// \brief Sets the map that stores the predecessor arcs.
-    ///
-    /// Sets the map that stores the predecessor arcs.
-    /// If you don't use this function before calling \ref run()
-    /// or \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    BellmanFord &predMap(PredMap &map) {
-      if(_local_pred) {
-        delete _pred;
-        _local_pred=false;
-      }
-      _pred = &map;
-      return *this;
-    }
-
-    /// \brief Sets the map that stores the distances of the nodes.
-    ///
-    /// Sets the map that stores the distances of the nodes calculated
-    /// by the algorithm.
-    /// If you don't use this function before calling \ref run()
-    /// or \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    BellmanFord &distMap(DistMap &map) {
-      if(_local_dist) {
-        delete _dist;
-        _local_dist=false;
-      }
-      _dist = &map;
-      return *this;
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the Bellman-Ford algorithm is to use
-    /// one of the member functions called \ref run().\n
-    /// If you need better control on the execution, you have to call
-    /// \ref init() first, then you can add several source nodes
-    /// with \ref addSource(). Finally the actual path computation can be
-    /// performed with \ref start(), \ref checkedStart() or
-    /// \ref limitedStart().
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures. The optional parameter
-    /// is the initial distance of each node.
-    void init(const Value value = OperationTraits::infinity()) {
-      create_maps();
-      for (NodeIt it(*_gr); it != INVALID; ++it) {
-        _pred->set(it, INVALID);
-        _dist->set(it, value);
-      }
-      _process.clear();
-      if (OperationTraits::less(value, OperationTraits::infinity())) {
-        for (NodeIt it(*_gr); it != INVALID; ++it) {
-          _process.push_back(it);
-          _mask->set(it, true);
-        }
-      } else {
-        for (NodeIt it(*_gr); it != INVALID; ++it) {
-          _mask->set(it, false);
-        }
-      }
-    }
-
-    /// \brief Adds a new source node.
-    ///
-    /// This function adds a new source node. The optional second parameter
-    /// is the initial distance of the node.
-    void addSource(Node source, Value dst = OperationTraits::zero()) {
-      _dist->set(source, dst);
-      if (!(*_mask)[source]) {
-        _process.push_back(source);
-        _mask->set(source, true);
-      }
-    }
-
-    /// \brief Executes one round from the Bellman-Ford algorithm.
-    ///
-    /// If the algoritm calculated the distances in the previous round
-    /// exactly for the paths of at most \c k arcs, then this function
-    /// will calculate the distances exactly for the paths of at most
-    /// <tt>k+1</tt> arcs. Performing \c k iterations using this function
-    /// calculates the shortest path distances exactly for the paths
-    /// consisting of at most \c k arcs.
-    ///
-    /// \warning The paths with limited arc number cannot be retrieved
-    /// easily with \ref path() or \ref predArc() functions. If you also
-    /// need the shortest paths and not only the distances, you should
-    /// store the \ref predMap() "predecessor map" after each iteration
-    /// and build the path manually.
-    ///
-    /// \return \c true when the algorithm have not found more shorter
-    /// paths.
-    ///
-    /// \see ActiveIt
-    bool processNextRound() {
-      for (int i = 0; i < int(_process.size()); ++i) {
-        _mask->set(_process[i], false);
-      }
-      std::vector<Node> nextProcess;
-      std::vector<Value> values(_process.size());
-      for (int i = 0; i < int(_process.size()); ++i) {
-        values[i] = (*_dist)[_process[i]];
-      }
-      for (int i = 0; i < int(_process.size()); ++i) {
-        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
-          Node target = _gr->target(it);
-          Value relaxed = OperationTraits::plus(values[i], (*_length)[it]);
-          if (OperationTraits::less(relaxed, (*_dist)[target])) {
-            _pred->set(target, it);
-            _dist->set(target, relaxed);
-            if (!(*_mask)[target]) {
-              _mask->set(target, true);
-              nextProcess.push_back(target);
-            }
-          }
-        }
-      }
-      _process.swap(nextProcess);
-      return _process.empty();
-    }
-
-    /// \brief Executes one weak round from the Bellman-Ford algorithm.
-    ///
-    /// If the algorithm calculated the distances in the previous round
-    /// at least for the paths of at most \c k arcs, then this function
-    /// will calculate the distances at least for the paths of at most
-    /// <tt>k+1</tt> arcs.
-    /// This function does not make it possible to calculate the shortest
-    /// path distances exactly for paths consisting of at most \c k arcs,
-    /// this is why it is called weak round.
-    ///
-    /// \return \c true when the algorithm have not found more shorter
-    /// paths.
-    ///
-    /// \see ActiveIt
-    bool processNextWeakRound() {
-      for (int i = 0; i < int(_process.size()); ++i) {
-        _mask->set(_process[i], false);
-      }
-      std::vector<Node> nextProcess;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        for (OutArcIt it(*_gr, _process[i]); it != INVALID; ++it) {
-          Node target = _gr->target(it);
-          Value relaxed =
-            OperationTraits::plus((*_dist)[_process[i]], (*_length)[it]);
-          if (OperationTraits::less(relaxed, (*_dist)[target])) {
-            _pred->set(target, it);
-            _dist->set(target, relaxed);
-            if (!(*_mask)[target]) {
-              _mask->set(target, true);
-              nextProcess.push_back(target);
-            }
-          }
-        }
-      }
-      _process.swap(nextProcess);
-      return _process.empty();
-    }
-
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the root node(s)
-    /// in order to compute the shortest path to each node.
-    ///
-    /// The algorithm computes
-    /// - the shortest path tree (forest),
-    /// - the distance of each node from the root(s).
-    ///
-    /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
-    void start() {
-      int num = countNodes(*_gr) - 1;
-      for (int i = 0; i < num; ++i) {
-        if (processNextWeakRound()) break;
-      }
-    }
-
-    /// \brief Executes the algorithm and checks the negative cycles.
-    ///
-    /// Executes the algorithm and checks the negative cycles.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the root node(s)
-    /// in order to compute the shortest path to each node and also checks
-    /// if the digraph contains cycles with negative total length.
-    ///
-    /// The algorithm computes
-    /// - the shortest path tree (forest),
-    /// - the distance of each node from the root(s).
-    ///
-    /// \return \c false if there is a negative cycle in the digraph.
-    ///
-    /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
-    bool checkedStart() {
-      int num = countNodes(*_gr);
-      for (int i = 0; i < num; ++i) {
-        if (processNextWeakRound()) return true;
-      }
-      return _process.empty();
-    }
-
-    /// \brief Executes the algorithm with arc number limit.
-    ///
-    /// Executes the algorithm with arc number limit.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the root node(s)
-    /// in order to compute the shortest path distance for each node
-    /// using only the paths consisting of at most \c num arcs.
-    ///
-    /// The algorithm computes
-    /// - the limited distance of each node from the root(s),
-    /// - the predecessor arc for each node.
-    ///
-    /// \warning The paths with limited arc number cannot be retrieved
-    /// easily with \ref path() or \ref predArc() functions. If you also
-    /// need the shortest paths and not only the distances, you should
-    /// store the \ref predMap() "predecessor map" after each iteration
-    /// and build the path manually.
-    ///
-    /// \pre init() must be called and at least one root node should be
-    /// added with addSource() before using this function.
-    void limitedStart(int num) {
-      for (int i = 0; i < num; ++i) {
-        if (processNextRound()) break;
-      }
-    }
-
-    /// \brief Runs the algorithm from the given root node.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the given root
-    /// node \c s in order to compute the shortest path to each node.
-    ///
-    /// The algorithm computes
-    /// - the shortest path tree (forest),
-    /// - the distance of each node from the root(s).
-    ///
-    /// \note bf.run(s) is just a shortcut of the following code.
-    /// \code
-    ///   bf.init();
-    ///   bf.addSource(s);
-    ///   bf.start();
-    /// \endcode
-    void run(Node s) {
-      init();
-      addSource(s);
-      start();
-    }
-
-    /// \brief Runs the algorithm from the given root node with arc
-    /// number limit.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the given root
-    /// node \c s in order to compute the shortest path distance for each
-    /// node using only the paths consisting of at most \c num arcs.
-    ///
-    /// The algorithm computes
-    /// - the limited distance of each node from the root(s),
-    /// - the predecessor arc for each node.
-    ///
-    /// \warning The paths with limited arc number cannot be retrieved
-    /// easily with \ref path() or \ref predArc() functions. If you also
-    /// need the shortest paths and not only the distances, you should
-    /// store the \ref predMap() "predecessor map" after each iteration
-    /// and build the path manually.
-    ///
-    /// \note bf.run(s, num) is just a shortcut of the following code.
-    /// \code
-    ///   bf.init();
-    ///   bf.addSource(s);
-    ///   bf.limitedStart(num);
-    /// \endcode
-    void run(Node s, int num) {
-      init();
-      addSource(s);
-      limitedStart(num);
-    }
-
-    ///@}
-
-    /// \brief LEMON iterator for getting the active nodes.
-    ///
-    /// This class provides a common style LEMON iterator that traverses
-    /// the active nodes of the Bellman-Ford algorithm after the last
-    /// phase. These nodes should be checked in the next phase to
-    /// find augmenting arcs outgoing from them.
-    class ActiveIt {
-    public:
-
-      /// \brief Constructor.
-      ///
-      /// Constructor for getting the active nodes of the given BellmanFord
-      /// instance.
-      ActiveIt(const BellmanFord& algorithm) : _algorithm(&algorithm)
-      {
-        _index = _algorithm->_process.size() - 1;
-      }
-
-      /// \brief Invalid constructor.
-      ///
-      /// Invalid constructor.
-      ActiveIt(Invalid) : _algorithm(0), _index(-1) {}
-
-      /// \brief Conversion to \c Node.
-      ///
-      /// Conversion to \c Node.
-      operator Node() const {
-        return _index >= 0 ? _algorithm->_process[_index] : INVALID;
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ActiveIt& operator++() {
-        --_index;
-        return *this;
-      }
-
-      bool operator==(const ActiveIt& it) const {
-        return static_cast<Node>(*this) == static_cast<Node>(it);
-      }
-      bool operator!=(const ActiveIt& it) const {
-        return static_cast<Node>(*this) != static_cast<Node>(it);
-      }
-      bool operator<(const ActiveIt& it) const {
-        return static_cast<Node>(*this) < static_cast<Node>(it);
-      }
-
-    private:
-      const BellmanFord* _algorithm;
-      int _index;
-    };
-
-    /// \name Query Functions
-    /// The result of the Bellman-Ford algorithm can be obtained using these
-    /// functions.\n
-    /// Either \ref run() or \ref init() should be called before using them.
-
-    ///@{
-
-    /// \brief The shortest path to the given node.
-    ///
-    /// Gives back the shortest path to the given node from the root(s).
-    ///
-    /// \warning \c t should be reached from the root(s).
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Path path(Node t) const
-    {
-      return Path(*_gr, *_pred, t);
-    }
-
-    /// \brief The distance of the given node from the root(s).
-    ///
-    /// Returns the distance of the given node from the root(s).
-    ///
-    /// \warning If node \c v is not reached from the root(s), then
-    /// the return value of this function is undefined.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Value dist(Node v) const { return (*_dist)[v]; }
-
-    /// \brief Returns the 'previous arc' of the shortest path tree for
-    /// the given node.
-    ///
-    /// This function returns the 'previous arc' of the shortest path
-    /// tree for node \c v, i.e. it returns the last arc of a
-    /// shortest path from a root to \c v. It is \c INVALID if \c v
-    /// is not reached from the root(s) or if \c v is a root.
-    ///
-    /// The shortest path tree used here is equal to the shortest path
-    /// tree used in \ref predNode() and \ref predMap().
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Arc predArc(Node v) const { return (*_pred)[v]; }
-
-    /// \brief Returns the 'previous node' of the shortest path tree for
-    /// the given node.
-    ///
-    /// This function returns the 'previous node' of the shortest path
-    /// tree for node \c v, i.e. it returns the last but one node of
-    /// a shortest path from a root to \c v. It is \c INVALID if \c v
-    /// is not reached from the root(s) or if \c v is a root.
-    ///
-    /// The shortest path tree used here is equal to the shortest path
-    /// tree used in \ref predArc() and \ref predMap().
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    Node predNode(Node v) const {
-      return (*_pred)[v] == INVALID ? INVALID : _gr->source((*_pred)[v]);
-    }
-
-    /// \brief Returns a const reference to the node map that stores the
-    /// distances of the nodes.
-    ///
-    /// Returns a const reference to the node map that stores the distances
-    /// of the nodes calculated by the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const DistMap &distMap() const { return *_dist;}
-
-    /// \brief Returns a const reference to the node map that stores the
-    /// predecessor arcs.
-    ///
-    /// Returns a const reference to the node map that stores the predecessor
-    /// arcs, which form the shortest path tree (forest).
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const PredMap &predMap() const { return *_pred; }
-
-    /// \brief Checks if a node is reached from the root(s).
-    ///
-    /// Returns \c true if \c v is reached from the root(s).
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    bool reached(Node v) const {
-      return (*_dist)[v] != OperationTraits::infinity();
-    }
-
-    /// \brief Gives back a negative cycle.
-    ///
-    /// This function gives back a directed cycle with negative total
-    /// length if the algorithm has already found one.
-    /// Otherwise it gives back an empty path.
-    lemon::Path<Digraph> negativeCycle() const {
-      typename Digraph::template NodeMap<int> state(*_gr, -1);
-      lemon::Path<Digraph> cycle;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        if (state[_process[i]] != -1) continue;
-        for (Node v = _process[i]; (*_pred)[v] != INVALID;
-             v = _gr->source((*_pred)[v])) {
-          if (state[v] == i) {
-            cycle.addFront((*_pred)[v]);
-            for (Node u = _gr->source((*_pred)[v]); u != v;
-                 u = _gr->source((*_pred)[u])) {
-              cycle.addFront((*_pred)[u]);
-            }
-            return cycle;
-          }
-          else if (state[v] >= 0) {
-            break;
-          }
-          state[v] = i;
-        }
-      }
-      return cycle;
-    }
-
-    ///@}
-  };
-
-  /// \brief Default traits class of bellmanFord() function.
-  ///
-  /// Default traits class of bellmanFord() function.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
-  template <typename GR, typename LEN>
-  struct BellmanFordWizardDefaultTraits {
-    /// The type of the digraph the algorithm runs on.
-    typedef GR Digraph;
-
-    /// \brief The type of the map that stores the arc lengths.
-    ///
-    /// The type of the map that stores the arc lengths.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef LEN LengthMap;
-
-    /// The type of the arc lengths.
-    typedef typename LEN::Value Value;
-
-    /// \brief Operation traits for Bellman-Ford algorithm.
-    ///
-    /// It defines the used operations and the infinity value for the
-    /// given \c Value type.
-    /// \see BellmanFordDefaultOperationTraits
-    typedef BellmanFordDefaultOperationTraits<Value> OperationTraits;
-
-    /// \brief The type of the map that stores the last
-    /// arcs of the shortest paths.
-    ///
-    /// The type of the map that stores the last arcs of the shortest paths.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<typename GR::Arc> PredMap;
-
-    /// \brief Instantiates a \c PredMap.
-    ///
-    /// This function instantiates a \ref PredMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref PredMap.
-    static PredMap *createPredMap(const GR &g) {
-      return new PredMap(g);
-    }
-
-    /// \brief The type of the map that stores the distances of the nodes.
-    ///
-    /// The type of the map that stores the distances of the nodes.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename GR::template NodeMap<Value> DistMap;
-
-    /// \brief Instantiates a \c DistMap.
-    ///
-    /// This function instantiates a \ref DistMap.
-    /// \param g is the digraph to which we would like to define the
-    /// \ref DistMap.
-    static DistMap *createDistMap(const GR &g) {
-      return new DistMap(g);
-    }
-
-    ///The type of the shortest paths.
-
-    ///The type of the shortest paths.
-    ///It must meet the \ref concepts::Path "Path" concept.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  /// \brief Default traits class used by BellmanFordWizard.
-  ///
-  /// Default traits class used by BellmanFordWizard.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
-  template <typename GR, typename LEN>
-  class BellmanFordWizardBase
-    : public BellmanFordWizardDefaultTraits<GR, LEN> {
-
-    typedef BellmanFordWizardDefaultTraits<GR, LEN> Base;
-  protected:
-    // Type of the nodes in the digraph.
-    typedef typename Base::Digraph::Node Node;
-
-    // Pointer to the underlying digraph.
-    void *_graph;
-    // Pointer to the length map
-    void *_length;
-    // Pointer to the map of predecessors arcs.
-    void *_pred;
-    // Pointer to the map of distances.
-    void *_dist;
-    //Pointer to the shortest path to the target node.
-    void *_path;
-    //Pointer to the distance of the target node.
-    void *_di;
-
-    public:
-    /// Constructor.
-
-    /// This constructor does not require parameters, it initiates
-    /// all of the attributes to default values \c 0.
-    BellmanFordWizardBase() :
-      _graph(0), _length(0), _pred(0), _dist(0), _path(0), _di(0) {}
-
-    /// Constructor.
-
-    /// This constructor requires two parameters,
-    /// others are initiated to \c 0.
-    /// \param gr The digraph the algorithm runs on.
-    /// \param len The length map.
-    BellmanFordWizardBase(const GR& gr,
-                          const LEN& len) :
-      _graph(reinterpret_cast<void*>(const_cast<GR*>(&gr))),
-      _length(reinterpret_cast<void*>(const_cast<LEN*>(&len))),
-      _pred(0), _dist(0), _path(0), _di(0) {}
-
-  };
-
-  /// \brief Auxiliary class for the function-type interface of the
-  /// \ref BellmanFord "Bellman-Ford" algorithm.
-  ///
-  /// This auxiliary class is created to implement the
-  /// \ref bellmanFord() "function-type interface" of the
-  /// \ref BellmanFord "Bellman-Ford" algorithm.
-  /// It does not have own \ref run() method, it uses the
-  /// functions and features of the plain \ref BellmanFord.
-  ///
-  /// This class should only be used through the \ref bellmanFord()
-  /// function, which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
-  template<class TR>
-  class BellmanFordWizard : public TR {
-    typedef TR Base;
-
-    typedef typename TR::Digraph Digraph;
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::OutArcIt ArcIt;
-
-    typedef typename TR::LengthMap LengthMap;
-    typedef typename LengthMap::Value Value;
-    typedef typename TR::PredMap PredMap;
-    typedef typename TR::DistMap DistMap;
-    typedef typename TR::Path Path;
-
-  public:
-    /// Constructor.
-    BellmanFordWizard() : TR() {}
-
-    /// \brief Constructor that requires parameters.
-    ///
-    /// Constructor that requires parameters.
-    /// These parameters will be the default values for the traits class.
-    /// \param gr The digraph the algorithm runs on.
-    /// \param len The length map.
-    BellmanFordWizard(const Digraph& gr, const LengthMap& len)
-      : TR(gr, len) {}
-
-    /// \brief Copy constructor
-    BellmanFordWizard(const TR &b) : TR(b) {}
-
-    ~BellmanFordWizard() {}
-
-    /// \brief Runs the Bellman-Ford algorithm from the given source node.
-    ///
-    /// This method runs the Bellman-Ford algorithm from the given source
-    /// node in order to compute the shortest path to each node.
-    void run(Node s) {
-      BellmanFord<Digraph,LengthMap,TR>
-        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
-           *reinterpret_cast<const LengthMap*>(Base::_length));
-      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
-      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-      bf.run(s);
-    }
-
-    /// \brief Runs the Bellman-Ford algorithm to find the shortest path
-    /// between \c s and \c t.
-    ///
-    /// This method runs the Bellman-Ford algorithm from node \c s
-    /// in order to compute the shortest path to node \c t.
-    /// Actually, it computes the shortest path to each node, but using
-    /// this function you can retrieve the distance and the shortest path
-    /// for a single target node easier.
-    ///
-    /// \return \c true if \c t is reachable form \c s.
-    bool run(Node s, Node t) {
-      BellmanFord<Digraph,LengthMap,TR>
-        bf(*reinterpret_cast<const Digraph*>(Base::_graph),
-           *reinterpret_cast<const LengthMap*>(Base::_length));
-      if (Base::_pred) bf.predMap(*reinterpret_cast<PredMap*>(Base::_pred));
-      if (Base::_dist) bf.distMap(*reinterpret_cast<DistMap*>(Base::_dist));
-      bf.run(s);
-      if (Base::_path) *reinterpret_cast<Path*>(Base::_path) = bf.path(t);
-      if (Base::_di) *reinterpret_cast<Value*>(Base::_di) = bf.dist(t);
-      return bf.reached(t);
-    }
-
-    template<class T>
-    struct SetPredMapBase : public Base {
-      typedef T PredMap;
-      static PredMap *createPredMap(const Digraph &) { return 0; };
-      SetPredMapBase(const TR &b) : TR(b) {}
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// the predecessor map.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// the map that stores the predecessor arcs of the nodes.
-    template<class T>
-    BellmanFordWizard<SetPredMapBase<T> > predMap(const T &t) {
-      Base::_pred=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BellmanFordWizard<SetPredMapBase<T> >(*this);
-    }
-
-    template<class T>
-    struct SetDistMapBase : public Base {
-      typedef T DistMap;
-      static DistMap *createDistMap(const Digraph &) { return 0; };
-      SetDistMapBase(const TR &b) : TR(b) {}
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// the distance map.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// the map that stores the distances of the nodes calculated
-    /// by the algorithm.
-    template<class T>
-    BellmanFordWizard<SetDistMapBase<T> > distMap(const T &t) {
-      Base::_dist=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BellmanFordWizard<SetDistMapBase<T> >(*this);
-    }
-
-    template<class T>
-    struct SetPathBase : public Base {
-      typedef T Path;
-      SetPathBase(const TR &b) : TR(b) {}
-    };
-
-    /// \brief \ref named-func-param "Named parameter" for getting
-    /// the shortest path to the target node.
-    ///
-    /// \ref named-func-param "Named parameter" for getting
-    /// the shortest path to the target node.
-    template<class T>
-    BellmanFordWizard<SetPathBase<T> > path(const T &t)
-    {
-      Base::_path=reinterpret_cast<void*>(const_cast<T*>(&t));
-      return BellmanFordWizard<SetPathBase<T> >(*this);
-    }
-
-    /// \brief \ref named-func-param "Named parameter" for getting
-    /// the distance of the target node.
-    ///
-    /// \ref named-func-param "Named parameter" for getting
-    /// the distance of the target node.
-    BellmanFordWizard dist(const Value &d)
-    {
-      Base::_di=reinterpret_cast<void*>(const_cast<Value*>(&d));
-      return *this;
-    }
-
-  };
-
-  /// \brief Function type interface for the \ref BellmanFord "Bellman-Ford"
-  /// algorithm.
-  ///
-  /// \ingroup shortest_path
-  /// Function type interface for the \ref BellmanFord "Bellman-Ford"
-  /// algorithm.
-  ///
-  /// This function also has several \ref named-templ-func-param
-  /// "named parameters", they are declared as the members of class
-  /// \ref BellmanFordWizard.
-  /// The following examples show how to use these parameters.
-  /// \code
-  ///   // Compute shortest path from node s to each node
-  ///   bellmanFord(g,length).predMap(preds).distMap(dists).run(s);
-  ///
-  ///   // Compute shortest path from s to t
-  ///   bool reached = bellmanFord(g,length).path(p).dist(d).run(s,t);
-  /// \endcode
-  /// \warning Don't forget to put the \ref BellmanFordWizard::run() "run()"
-  /// to the end of the parameter list.
-  /// \sa BellmanFordWizard
-  /// \sa BellmanFord
-  template<typename GR, typename LEN>
-  BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >
-  bellmanFord(const GR& digraph,
-              const LEN& length)
-  {
-    return BellmanFordWizard<BellmanFordWizardBase<GR,LEN> >(digraph, length);
-  }
-
-} //END OF NAMESPACE LEMON
-
-#endif
-
Index: lemon/bfs.h
===================================================================
--- lemon/bfs.h	(revision 976)
+++ lemon/bfs.h	(revision 975)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -48,5 +48,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -63,6 +63,5 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -83,6 +82,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -99,5 +97,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
@@ -123,9 +121,4 @@
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref BfsDefaultTraits
-  ///"BfsDefaultTraits<GR>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
@@ -233,5 +226,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Bfs< Digraph, SetPredMapTraits<T> > {
@@ -253,5 +246,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Bfs< Digraph, SetDistMapTraits<T> > {
@@ -273,6 +266,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Bfs< Digraph, SetReachedMapTraits<T> > {
@@ -294,5 +286,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Bfs< Digraph, SetProcessedMapTraits<T> > {
@@ -422,6 +414,6 @@
     ///The simplest way to execute the BFS algorithm is to use one of the
     ///member functions called \ref run(Node) "run()".\n
-    ///If you need better control on the execution, you have to call
-    ///\ref init() first, then you can add several source nodes with
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), then you can add several source nodes with
     ///\ref addSource(). Finally the actual path computation can be
     ///performed with one of the \ref start() functions.
@@ -709,6 +701,10 @@
     ///Runs the algorithm to visit all nodes in the digraph.
 
-    ///This method runs the %BFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs the %BFS algorithm in order to
+    ///compute the shortest path to each node.
+    ///
+    ///The algorithm computes
+    ///- the shortest path tree (forest),
+    ///- the distance of each node from the root(s).
     ///
     ///\note <tt>b.run(s)</tt> is just a shortcut of the following code.
@@ -742,7 +738,7 @@
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns the shortest path to the given node from the root(s).
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -752,7 +748,7 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -763,7 +759,6 @@
     int dist(Node v) const { return (*_dist)[v]; }
 
-    ///\brief Returns the 'previous arc' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous arc' of the shortest path tree for a node.
+
     ///This function returns the 'previous arc' of the shortest path
     ///tree for the node \c v, i.e. it returns the last arc of a
@@ -772,5 +767,5 @@
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predNode() and \ref predMap().
+    ///tree used in \ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -778,14 +773,13 @@
     Arc predArc(Node v) const { return (*_pred)[v];}
 
-    ///\brief Returns the 'previous node' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous node' of the shortest path tree for a node.
+
     ///This function returns the 'previous node' of the shortest path
     ///tree for the node \c v, i.e. it returns the last but one node
-    ///of a shortest path from a root to \c v. It is \c INVALID
+    ///from a shortest path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predArc() and \ref predMap().
+    ///tree used in \ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -808,5 +802,5 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
+    ///arcs, which form the shortest path tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -814,5 +808,5 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -840,5 +834,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -855,6 +849,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
@@ -875,6 +869,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -891,5 +884,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
@@ -906,5 +899,5 @@
 
     ///The type of the shortest paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -912,6 +905,10 @@
   /// Default traits class used by BfsWizard
 
-  /// Default traits class used by BfsWizard.
-  /// \tparam GR The type of the digraph.
+  /// To make it easier to use Bfs algorithm
+  /// we have created a wizard class.
+  /// This \ref BfsWizard class needs default traits,
+  /// as well as the \ref Bfs class.
+  /// The \ref BfsWizardBase is a class to be the default traits of the
+  /// \ref BfsWizard class.
   template<class GR>
   class BfsWizardBase : public BfsWizardDefaultTraits<GR>
@@ -941,5 +938,5 @@
     /// Constructor.
 
-    /// This constructor does not require parameters, it initiates
+    /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to \c 0.
     BfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -966,7 +963,4 @@
   /// This class should only be used through the \ref bfs() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class BfsWizard : public TR
@@ -974,4 +968,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -981,8 +976,14 @@
     typedef typename Digraph::OutArcIt OutArcIt;
 
+    ///\brief The type of the map that stores the predecessor
+    ///arcs of the shortest paths.
     typedef typename TR::PredMap PredMap;
+    ///\brief The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
+    ///\brief The type of the map that indicates which nodes are reached.
     typedef typename TR::ReachedMap ReachedMap;
+    ///\brief The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
+    ///The type of the shortest paths
     typedef typename TR::Path Path;
 
@@ -1054,6 +1055,6 @@
     ///Runs BFS algorithm to visit all nodes in the digraph.
 
-    ///This method runs BFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs BFS algorithm in order to compute
+    ///the shortest path to each node.
     void run()
     {
@@ -1067,10 +1068,9 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the predecessor map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the predecessor arcs of the nodes.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     BfsWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1086,10 +1086,9 @@
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the reached map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are reached.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
     template<class T>
     BfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
@@ -1105,11 +1104,9 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the distance map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the distances of the nodes calculated
-    ///by the algorithm.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     BfsWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1125,10 +1122,9 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-func-param "Named parameter" for setting
-    ///the processed map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are processed.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     BfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1270,6 +1266,5 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1309,9 +1304,9 @@
   /// does not observe the BFS events. If you want to observe the BFS
   /// events, you should implement your own visitor class.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref BfsVisitDefaultTraits
-  /// "BfsVisitDefaultTraits<GR>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// \tparam TR Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref BfsVisitDefaultTraits "BfsVisitDefaultTraits<GR>".
+  /// See \ref BfsVisitDefaultTraits for the documentation of
+  /// a BFS visit traits class.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
@@ -1432,6 +1427,6 @@
     /// The simplest way to execute the BFS algorithm is to use one of the
     /// member functions called \ref run(Node) "run()".\n
-    /// If you need better control on the execution, you have to call
-    /// \ref init() first, then you can add several source nodes with
+    /// If you need more control on the execution, first you have to call
+    /// \ref init(), then you can add several source nodes with
     /// \ref addSource(). Finally the actual path computation can be
     /// performed with one of the \ref start() functions.
@@ -1705,6 +1700,10 @@
     /// \brief Runs the algorithm to visit all nodes in the digraph.
     ///
-    /// This method runs the %BFS algorithm in order to visit all nodes
-    /// in the digraph.
+    /// This method runs the %BFS algorithm in order to
+    /// compute the shortest path to each node.
+    ///
+    /// The algorithm computes
+    /// - the shortest path tree (forest),
+    /// - the distance of each node from the root(s).
     ///
     /// \note <tt>b.run(s)</tt> is just a shortcut of the following code.
@@ -1738,5 +1737,5 @@
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
+    /// \brief Checks if a node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).
Index: lemon/bin_heap.h
===================================================================
--- lemon/bin_heap.h	(revision 711)
+++ lemon/bin_heap.h	(revision 683)
@@ -20,7 +20,7 @@
 #define LEMON_BIN_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Binary heap implementation.
+///\brief Binary Heap implementation.
 
 #include <vector>
@@ -30,39 +30,43 @@
 namespace lemon {
 
-  /// \ingroup heaps
-  ///
-  /// \brief Binary heap data structure.
-  ///
-  /// This class implements the \e binary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
+  ///\ingroup auxdat
+  ///
+  ///\brief A Binary Heap implementation.
+  ///
+  ///This class implements the \e binary \e heap data structure.
+  ///
+  ///A \e heap is a data structure for storing items with specified values
+  ///called \e priorities in such a way that finding the item with minimum
+  ///priority is efficient. \c CMP specifies the ordering of the priorities.
+  ///In a heap one can change the priority of an item, add or erase an
+  ///item, etc.
+  ///
+  ///\tparam PR Type of the priority of the items.
+  ///\tparam IM A read and writable item map with int values, used internally
+  ///to handle the cross references.
+  ///\tparam CMP A functor class for the ordering of the priorities.
+  ///The default is \c std::less<PR>.
+  ///
+  ///\sa FibHeap
+  ///\sa Dijkstra
   template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
   class BinHeap {
+
   public:
-
-    /// Type of the item-int map.
+    ///\e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
+    ///\e
     typedef PR Prio;
-    /// Type of the items stored in the heap.
+    ///\e
     typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
+    ///\e
     typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
+    ///\e
     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
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -81,41 +85,40 @@
 
   public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// must be \c PRE_HEAP (<tt>-1</tt>) for every item.
     explicit BinHeap(ItemIntMap &map) : _iim(map) {}
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
+    ///
+    /// \param comp The comparator function object.
     BinHeap(ItemIntMap &map, const Compare &comp)
       : _iim(map), _comp(comp) {}
 
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
     int size() const { return _data.size(); }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _data.empty(); }
 
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference map.
+    /// If you want to reuse what is not surely empty you should first clear
+    /// the heap and after that you should set the cross reference map for
+    /// each item to \c PRE_HEAP.
     void clear() {
       _data.clear();
@@ -125,10 +128,10 @@
     static int parent(int i) { return (i-1)/2; }
 
-    static int secondChild(int i) { return 2*i+2; }
+    static int second_child(int i) { return 2*i+2; }
     bool less(const Pair &p1, const Pair &p2) const {
       return _comp(p1.second, p2.second);
     }
 
-    int bubbleUp(int hole, Pair p) {
+    int bubble_up(int hole, Pair p) {
       int par = parent(hole);
       while( hole>0 && less(p,_data[par]) ) {
@@ -141,6 +144,6 @@
     }
 
-    int bubbleDown(int hole, Pair p, int length) {
-      int child = secondChild(hole);
+    int bubble_down(int hole, Pair p, int length) {
+      int child = second_child(hole);
       while(child < length) {
         if( less(_data[child-1], _data[child]) ) {
@@ -151,5 +154,5 @@
         move(_data[child], hole);
         hole = child;
-        child = secondChild(hole);
+        child = second_child(hole);
       }
       child--;
@@ -169,45 +172,42 @@
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \c p.first to the heap with priority \c p.second.
     /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair &p) {
       int n = _data.size();
       _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+      bubble_up(n, p);
+    }
+
+    /// \brief Insert an item into the heap with the given heap.
+    ///
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority relative to \c Compare.
+    ///
+    /// This method returns the item with minimum priority relative to \c
+    /// Compare.
+    /// \pre The heap must be nonempty.
     Item top() const {
       return _data[0].first;
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority relative to \c Compare.
+    ///
+    /// It returns the minimum priority relative to \c Compare.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       return _data[0].second;
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority relative to \c Compare.
+    ///
+    /// This method deletes the item with minimum priority relative to \c
+    /// Compare from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -215,15 +215,14 @@
       _iim.set(_data[0].first, POST_HEAP);
       if (n > 0) {
-        bubbleDown(0, _data[n], n);
+        bubble_down(0, _data[n], n);
       }
       _data.pop_back();
     }
 
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap.
+    /// \param i The item to erase.
+    /// \pre The item should be in the heap.
     void erase(const Item &i) {
       int h = _iim[i];
@@ -231,6 +230,6 @@
       _iim.set(_data[h].first, POST_HEAP);
       if( h < n ) {
-        if ( bubbleUp(h, _data[n]) == h) {
-          bubbleDown(h, _data[n], n);
+        if ( bubble_up(h, _data[n]) == h) {
+          bubble_down(h, _data[n], n);
         }
       }
@@ -238,9 +237,10 @@
     }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
+
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \param i The item.
+    /// \pre \c i must be in the heap.
     Prio operator[](const Item &i) const {
       int idx = _iim[i];
@@ -248,10 +248,9 @@
     }
 
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
     /// \param i The item.
     /// \param p The priority.
@@ -262,40 +261,42 @@
       }
       else if( _comp(p, _data[idx].second) ) {
-        bubbleUp(idx, Pair(i,p));
+        bubble_up(idx, Pair(i,p));
       }
       else {
-        bubbleDown(idx, Pair(i,p), _data.size());
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+        bubble_down(idx, Pair(i,p), _data.size());
+      }
+    }
+
+    /// \brief Decreases the priority of \c i to \c p.
+    ///
+    /// This method decreases the priority of item \c i to \c p.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
+    /// \pre \c i must be stored in the heap with priority at least \c
+    /// p relative to \c Compare.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+      bubble_up(idx, Pair(i,p));
+    }
+
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
+      bubble_down(idx, Pair(i,p), _data.size());
+    }
+
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
@@ -306,9 +307,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -327,11 +328,10 @@
     }
 
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
+    /// \brief Replaces an item in the heap.
+    ///
+    /// The \c i item is replaced with \c j item. The \c i item should
+    /// be in the heap, while the \c j should be out of the heap. The
+    /// \c i item will out of the heap and \c j will be in the heap
+    /// with the same prioriority as prevoiusly the \c i item.
     void replace(const Item& i, const Item& j) {
       int idx = _iim[i];
Index: mon/binomial_heap.h
===================================================================
--- lemon/binomial_heap.h	(revision 877)
+++ 	(revision )
@@ -1,445 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_BINOMIAL_HEAP_H
-#define LEMON_BINOMIAL_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Binomial Heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-#include <lemon/math.h>
-#include <lemon/counter.h>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Binomial heap data structure.
-  ///
-  /// This class implements the \e binomial \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The methods \ref increase() and \ref erase() are not efficient
-  /// in a binomial heap. In case of many calls of these operations,
-  /// it is better to use other heap structure, e.g. \ref BinHeap
-  /// "binary heap".
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class BinomialHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    class Store;
-
-    std::vector<Store> _data;
-    int _min, _head;
-    ItemIntMap &_iim;
-    Compare _comp;
-    int _num_items;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit BinomialHeap(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.
-    BinomialHeap(ItemIntMap &map, const Compare &comp)
-      : _min(0), _head(-1), _iim(map), _comp(comp), _num_items(0) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _num_items; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _num_items==0; }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() {
-      _data.clear(); _min=0; _num_items=0; _head=-1;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param item The item.
-    /// \param value The priority.
-    void set (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        if ( _comp(value, _data[i].prio) ) decrease(item, value);
-        if ( _comp(_data[i].prio, value) ) increase(item, value);
-      } else push(item, value);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param item The item to insert.
-    /// \param value The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i<0 ) {
-        int s=_data.size();
-        _iim.set( item,s );
-        Store st;
-        st.name=item;
-        st.prio=value;
-        _data.push_back(st);
-        i=s;
-      }
-      else {
-        _data[i].parent=_data[i].right_neighbor=_data[i].child=-1;
-        _data[i].degree=0;
-        _data[i].in=true;
-        _data[i].prio=value;
-      }
-
-      if( 0==_num_items ) {
-        _head=i;
-        _min=i;
-      } else {
-        merge(i);
-        if( _comp(_data[i].prio, _data[_min].prio) ) _min=i;
-      }
-      ++_num_items;
-    }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[_min].name; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[_min].prio; }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    const Prio& operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      _data[_min].in=false;
-
-      int head_child=-1;
-      if ( _data[_min].child!=-1 ) {
-        int child=_data[_min].child;
-        int neighb;
-        while( child!=-1 ) {
-          neighb=_data[child].right_neighbor;
-          _data[child].parent=-1;
-          _data[child].right_neighbor=head_child;
-          head_child=child;
-          child=neighb;
-        }
-      }
-
-      if ( _data[_head].right_neighbor==-1 ) {
-        // there was only one root
-        _head=head_child;
-      }
-      else {
-        // there were more roots
-        if( _head!=_min )  { unlace(_min); }
-        else { _head=_data[_head].right_neighbor; }
-        merge(head_child);
-      }
-      _min=findMin();
-      --_num_items;
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param item The item to delete.
-    /// \pre \e item must be in the heap.
-    void erase (const Item& item) {
-      int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        decrease( item, _data[_min].prio-1 );
-        pop();
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e value.
-    void decrease (Item item, const Prio& value) {
-      int i=_iim[item];
-      int p=_data[i].parent;
-      _data[i].prio=value;
-
-      while( p!=-1 && _comp(value, _data[p].prio) ) {
-        _data[i].name=_data[p].name;
-        _data[i].prio=_data[p].prio;
-        _data[p].name=item;
-        _data[p].prio=value;
-        _iim[_data[i].name]=i;
-        i=p;
-        p=_data[p].parent;
-      }
-      _iim[item]=i;
-      if ( _comp(value, _data[_min].prio) ) _min=i;
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e value.
-    void increase (Item item, const Prio& value) {
-      erase(item);
-      push(item, value);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param item The item.
-    State state(const Item &item) const {
-      int i=_iim[item];
-      if( i>=0 ) {
-        if ( _data[i].in ) i=0;
-        else i=-2;
-      }
-      return State(i);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-      case POST_HEAP:
-      case PRE_HEAP:
-        if (state(i) == IN_HEAP) {
-          erase(i);
-        }
-        _iim[i] = st;
-        break;
-      case IN_HEAP:
-        break;
-      }
-    }
-
-  private:
-
-    // Find the minimum of the roots
-    int findMin() {
-      if( _head!=-1 ) {
-        int min_loc=_head, min_val=_data[_head].prio;
-        for( int x=_data[_head].right_neighbor; x!=-1;
-             x=_data[x].right_neighbor ) {
-          if( _comp( _data[x].prio,min_val ) ) {
-            min_val=_data[x].prio;
-            min_loc=x;
-          }
-        }
-        return min_loc;
-      }
-      else return -1;
-    }
-
-    // Merge the heap with another heap starting at the given position
-    void merge(int a) {
-      if( _head==-1 || a==-1 ) return;
-      if( _data[a].right_neighbor==-1 &&
-          _data[a].degree<=_data[_head].degree ) {
-        _data[a].right_neighbor=_head;
-        _head=a;
-      } else {
-        interleave(a);
-      }
-      if( _data[_head].right_neighbor==-1 ) return;
-
-      int x=_head;
-      int x_prev=-1, x_next=_data[x].right_neighbor;
-      while( x_next!=-1 ) {
-        if( _data[x].degree!=_data[x_next].degree ||
-            ( _data[x_next].right_neighbor!=-1 &&
-              _data[_data[x_next].right_neighbor].degree==_data[x].degree ) ) {
-          x_prev=x;
-          x=x_next;
-        }
-        else {
-          if( _comp(_data[x_next].prio,_data[x].prio) ) {
-            if( x_prev==-1 ) {
-              _head=x_next;
-            } else {
-              _data[x_prev].right_neighbor=x_next;
-            }
-            fuse(x,x_next);
-            x=x_next;
-          }
-          else {
-            _data[x].right_neighbor=_data[x_next].right_neighbor;
-            fuse(x_next,x);
-          }
-        }
-        x_next=_data[x].right_neighbor;
-      }
-    }
-
-    // Interleave the elements of the given list into the list of the roots
-    void interleave(int a) {
-      int p=_head, q=a;
-      int curr=_data.size();
-      _data.push_back(Store());
-
-      while( p!=-1 || q!=-1 ) {
-        if( q==-1 || ( p!=-1 && _data[p].degree<_data[q].degree ) ) {
-          _data[curr].right_neighbor=p;
-          curr=p;
-          p=_data[p].right_neighbor;
-        }
-        else {
-          _data[curr].right_neighbor=q;
-          curr=q;
-          q=_data[q].right_neighbor;
-        }
-      }
-
-      _head=_data.back().right_neighbor;
-      _data.pop_back();
-    }
-
-    // Lace node a under node b
-    void fuse(int a, int b) {
-      _data[a].parent=b;
-      _data[a].right_neighbor=_data[b].child;
-      _data[b].child=a;
-
-      ++_data[b].degree;
-    }
-
-    // Unlace node a (if it has siblings)
-    void unlace(int a) {
-      int neighb=_data[a].right_neighbor;
-      int other=_head;
-
-      while( _data[other].right_neighbor!=a )
-        other=_data[other].right_neighbor;
-      _data[other].right_neighbor=neighb;
-    }
-
-  private:
-
-    class Store {
-      friend class BinomialHeap;
-
-      Item name;
-      int parent;
-      int right_neighbor;
-      int child;
-      int degree;
-      bool in;
-      Prio prio;
-
-      Store() : parent(-1), right_neighbor(-1), child(-1), degree(0),
-        in(true) {}
-    };
-  };
-
-} //namespace lemon
-
-#endif //LEMON_BINOMIAL_HEAP_H
-
Index: lemon/bits/alteration_notifier.h
===================================================================
--- lemon/bits/alteration_notifier.h	(revision 979)
+++ lemon/bits/alteration_notifier.h	(revision 440)
@@ -24,5 +24,4 @@
 
 #include <lemon/core.h>
-#include <lemon/bits/lock.h>
 
 //\ingroup graphbits
@@ -253,5 +252,5 @@
     typedef std::list<ObserverBase*> Observers;
     Observers _observers;
-    lemon::bits::Lock _lock;
+
 
   public:
@@ -334,16 +333,12 @@
 
     void attach(ObserverBase& observer) {
-      _lock.lock();
       observer._index = _observers.insert(_observers.begin(), &observer);
       observer._notifier = this;
-      _lock.unlock();
     }
 
     void detach(ObserverBase& observer) {
-      _lock.lock();
       _observers.erase(observer._index);
       observer._index = _observers.end();
       observer._notifier = 0;
-      _lock.unlock();
     }
 
Index: lemon/bits/array_map.h
===================================================================
--- lemon/bits/array_map.h	(revision 877)
+++ lemon/bits/array_map.h	(revision 617)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,5 +71,5 @@
 
   private:
-
+  
     // The MapBase of the Map which imlements the core regisitry function.
     typedef typename Notifier::ObserverBase Parent;
Index: lemon/bits/default_map.h
===================================================================
--- lemon/bits/default_map.h	(revision 877)
+++ lemon/bits/default_map.h	(revision 627)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -158,5 +158,5 @@
   public:
     typedef DefaultMap<_Graph, _Item, _Value> Map;
-
+    
     typedef typename Parent::GraphType GraphType;
     typedef typename Parent::Value Value;
Index: lemon/bits/edge_set_extender.h
===================================================================
--- lemon/bits/edge_set_extender.h	(revision 966)
+++ lemon/bits/edge_set_extender.h	(revision 962)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * 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-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -64,9 +64,9 @@
     Node oppositeNode(const Node &n, const Arc &e) const {
       if (n == Parent::source(e))
-        return Parent::target(e);
+	return Parent::target(e);
       else if(n==Parent::target(e))
-        return Parent::source(e);
+	return Parent::source(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -92,5 +92,5 @@
     // Iterable extensions
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Digraph* digraph;
     public:
@@ -101,19 +101,19 @@
 
       explicit NodeIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Digraph& _graph, const Node& node)
-        : Node(node), digraph(&_graph) {}
-
-      NodeIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Digraph& _graph, const Node& node) 
+	: Node(node), digraph(&_graph) {}
+
+      NodeIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -124,19 +124,19 @@
 
       explicit ArcIt(const Digraph& _graph) : digraph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Digraph& _graph, const Arc& e) :
-        Arc(e), digraph(&_graph) { }
-
-      ArcIt& operator++() {
-        digraph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Digraph& _graph, const Arc& e) : 
+	Arc(e), digraph(&_graph) { }
+
+      ArcIt& operator++() { 
+	digraph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -146,21 +146,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Digraph& _graph, const Arc& arc)
-        : Arc(arc), digraph(&_graph) {}
-
-      OutArcIt& operator++() {
-        digraph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
+      OutArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Digraph& _graph, const Arc& arc) 
+	: Arc(arc), digraph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	digraph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Digraph* digraph;
     public:
@@ -170,15 +170,15 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Digraph& _graph, const Node& node)
-        : digraph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Digraph& _graph, const Arc& arc) :
-        Arc(arc), digraph(&_graph) {}
-
-      InArcIt& operator++() {
-        digraph->nextIn(*this);
-        return *this;
+      InArcIt(const Digraph& _graph, const Node& node) 
+	: digraph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Digraph& _graph, const Arc& arc) : 
+	Arc(arc), digraph(&_graph) {}
+
+      InArcIt& operator++() { 
+	digraph->nextIn(*this);
+	return *this; 
       }
 
@@ -216,18 +216,18 @@
 
     // Mappable extension
-
+    
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Digraph& _g)
-        : Parent(_g) {}
-      ArcMap(const Digraph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Digraph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Digraph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -235,5 +235,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -248,5 +248,5 @@
       return arc;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -313,9 +313,9 @@
     Node oppositeNode(const Node &n, const Edge &e) const {
       if( n == Parent::u(e))
-        return Parent::v(e);
+	return Parent::v(e);
       else if( n == Parent::v(e))
-        return Parent::u(e);
+	return Parent::u(e);
       else
-        return INVALID;
+	return INVALID;
     }
 
@@ -341,5 +341,5 @@
 
     using Parent::notifier;
-
+    
     ArcNotifier& notifier(Arc) const {
       return arc_notifier;
@@ -351,5 +351,5 @@
 
 
-    class NodeIt : public Node {
+    class NodeIt : public Node { 
       const Graph* graph;
     public:
@@ -360,19 +360,19 @@
 
       explicit NodeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Node&>(*this));
-      }
-
-      NodeIt(const Graph& _graph, const Node& node)
-        : Node(node), graph(&_graph) {}
-
-      NodeIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class ArcIt : public Arc {
+	_graph.first(static_cast<Node&>(*this));
+      }
+
+      NodeIt(const Graph& _graph, const Node& node) 
+	: Node(node), graph(&_graph) {}
+
+      NodeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class ArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -383,19 +383,19 @@
 
       explicit ArcIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Arc&>(*this));
-      }
-
-      ArcIt(const Graph& _graph, const Arc& e) :
-        Arc(e), graph(&_graph) { }
-
-      ArcIt& operator++() {
-        graph->next(*this);
-        return *this;
-      }
-
-    };
-
-
-    class OutArcIt : public Arc {
+	_graph.first(static_cast<Arc&>(*this));
+      }
+
+      ArcIt(const Graph& _graph, const Arc& e) : 
+	Arc(e), graph(&_graph) { }
+
+      ArcIt& operator++() { 
+	graph->next(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class OutArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -405,21 +405,21 @@
       OutArcIt(Invalid i) : Arc(i) { }
 
-      OutArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstOut(*this, node);
-      }
-
-      OutArcIt(const Graph& _graph, const Arc& arc)
-        : Arc(arc), graph(&_graph) {}
-
-      OutArcIt& operator++() {
-        graph->nextOut(*this);
-        return *this;
-      }
-
-    };
-
-
-    class InArcIt : public Arc {
+      OutArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstOut(*this, node);
+      }
+
+      OutArcIt(const Graph& _graph, const Arc& arc) 
+	: Arc(arc), graph(&_graph) {}
+
+      OutArcIt& operator++() { 
+	graph->nextOut(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class InArcIt : public Arc { 
       const Graph* graph;
     public:
@@ -429,21 +429,21 @@
       InArcIt(Invalid i) : Arc(i) { }
 
-      InArcIt(const Graph& _graph, const Node& node)
-        : graph(&_graph) {
-        _graph.firstIn(*this, node);
-      }
-
-      InArcIt(const Graph& _graph, const Arc& arc) :
-        Arc(arc), graph(&_graph) {}
-
-      InArcIt& operator++() {
-        graph->nextIn(*this);
-        return *this;
-      }
-
-    };
-
-
-    class EdgeIt : public Parent::Edge {
+      InArcIt(const Graph& _graph, const Node& node) 
+	: graph(&_graph) {
+	_graph.firstIn(*this, node);
+      }
+
+      InArcIt(const Graph& _graph, const Arc& arc) : 
+	Arc(arc), graph(&_graph) {}
+
+      InArcIt& operator++() { 
+	graph->nextIn(*this);
+	return *this; 
+      }
+
+    };
+
+
+    class EdgeIt : public Parent::Edge { 
       const Graph* graph;
     public:
@@ -454,13 +454,13 @@
 
       explicit EdgeIt(const Graph& _graph) : graph(&_graph) {
-        _graph.first(static_cast<Edge&>(*this));
-      }
-
-      EdgeIt(const Graph& _graph, const Edge& e) :
-        Edge(e), graph(&_graph) { }
-
-      EdgeIt& operator++() {
-        graph->next(*this);
-        return *this;
+	_graph.first(static_cast<Edge&>(*this));
+      }
+
+      EdgeIt(const Graph& _graph, const Edge& e) : 
+	Edge(e), graph(&_graph) { }
+
+      EdgeIt& operator++() { 
+	graph->next(*this);
+	return *this; 
       }
 
@@ -478,15 +478,15 @@
 
       IncEdgeIt(const Graph& _graph, const Node &n) : graph(&_graph) {
-        _graph.firstInc(*this, direction, n);
+	_graph.firstInc(*this, direction, n);
       }
 
       IncEdgeIt(const Graph& _graph, const Edge &ue, const Node &n)
-        : graph(&_graph), Edge(ue) {
-        direction = (_graph.source(ue) == n);
+	: graph(&_graph), Edge(ue) {
+	direction = (_graph.source(ue) == n);
       }
 
       IncEdgeIt& operator++() {
-        graph->nextInc(*this, direction);
-        return *this;
+	graph->nextInc(*this, direction);
+	return *this; 
       }
     };
@@ -535,16 +535,16 @@
 
     template <typename _Value>
-    class ArcMap
+    class ArcMap 
       : public MapExtender<DefaultMap<Graph, Arc, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Arc, _Value> > Parent;
 
     public:
-      explicit ArcMap(const Graph& _g)
-        : Parent(_g) {}
-      ArcMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit ArcMap(const Graph& _g) 
+	: Parent(_g) {}
+      ArcMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       ArcMap& operator=(const ArcMap& cmap) {
-        return operator=<ArcMap>(cmap);
+	return operator=<ArcMap>(cmap);
       }
 
@@ -552,5 +552,5 @@
       ArcMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -559,17 +559,17 @@
 
     template <typename _Value>
-    class EdgeMap
+    class EdgeMap 
       : public MapExtender<DefaultMap<Graph, Edge, _Value> > {
       typedef MapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 
     public:
-      explicit EdgeMap(const Graph& _g)
-        : Parent(_g) {}
-
-      EdgeMap(const Graph& _g, const _Value& _v)
-        : Parent(_g, _v) {}
+      explicit EdgeMap(const Graph& _g) 
+	: Parent(_g) {}
+
+      EdgeMap(const Graph& _g, const _Value& _v) 
+	: Parent(_g, _v) {}
 
       EdgeMap& operator=(const EdgeMap& cmap) {
-        return operator=<EdgeMap>(cmap);
+	return operator=<EdgeMap>(cmap);
       }
 
@@ -577,5 +577,5 @@
       EdgeMap& operator=(const CMap& cmap) {
         Parent::operator=(cmap);
-        return *this;
+	return *this;
       }
 
@@ -594,5 +594,5 @@
       return edge;
     }
-
+    
     void clear() {
       notifier(Arc()).clear();
@@ -620,5 +620,5 @@
       arc_notifier.clear();
     }
-
+    
   };
 
Index: lemon/bits/graph_extender.h
===================================================================
--- lemon/bits/graph_extender.h	(revision 778)
+++ lemon/bits/graph_extender.h	(revision 685)
@@ -57,9 +57,9 @@
     }
 
-    static Node fromId(int id, Node) {
+    Node fromId(int id, Node) const {
       return Parent::nodeFromId(id);
     }
 
-    static Arc fromId(int id, Arc) {
+    Arc fromId(int id, Arc) const {
       return Parent::arcFromId(id);
     }
@@ -356,13 +356,13 @@
     }
 
-    static Node fromId(int id, Node) {
+    Node fromId(int id, Node) const {
       return Parent::nodeFromId(id);
     }
 
-    static Arc fromId(int id, Arc) {
+    Arc fromId(int id, Arc) const {
       return Parent::arcFromId(id);
     }
 
-    static Edge fromId(int id, Edge) {
+    Edge fromId(int id, Edge) const {
       return Parent::edgeFromId(id);
     }
Index: mon/bits/lock.h
===================================================================
--- lemon/bits/lock.h	(revision 979)
+++ 	(revision )
@@ -1,65 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2012
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_BITS_LOCK_H
-#define LEMON_BITS_LOCK_H
-
-#include <lemon/config.h>
-#if defined(LEMON_USE_PTHREAD)
-#include <pthread.h>
-#elif defined(LEMON_USE_WIN32_THREADS)
-#include <lemon/bits/windows.h>
-#endif
-
-namespace lemon {
-  namespace bits {
-
-#if defined(LEMON_USE_PTHREAD)
-    class Lock {
-    public:
-      Lock() {
-	pthread_mutex_init(&_lock, 0);
-      }
-      ~Lock() {
-	pthread_mutex_destroy(&_lock);
-      }
-      void lock() {
-	pthread_mutex_lock(&_lock);
-      }
-      void unlock() {
-	pthread_mutex_unlock(&_lock);
-      }
-
-    private:
-      pthread_mutex_t _lock;
-    };
-#elif defined(LEMON_USE_WIN32_THREADS)
-    class Lock : public WinLock {};
-#else
-    class Lock {
-    public:
-      Lock() {}
-      ~Lock() {}
-      void lock() {}
-      void unlock() {}
-    };    
-#endif
-  }
-}
-
-#endif
Index: lemon/bits/solver_bits.h
===================================================================
--- lemon/bits/solver_bits.h	(revision 989)
+++ lemon/bits/solver_bits.h	(revision 988)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/bits/windows.cc
===================================================================
--- lemon/bits/windows.cc	(revision 979)
+++ lemon/bits/windows.cc	(revision 940)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -99,5 +99,5 @@
       GetSystemTime(&time);
       char buf1[11], buf2[9], buf3[5];
-          if (GetDateFormat(MY_LOCALE, 0, &time,
+	  if (GetDateFormat(MY_LOCALE, 0, &time,
                         ("ddd MMM dd"), buf1, 11) &&
           GetTimeFormat(MY_LOCALE, 0, &time,
@@ -131,34 +131,4 @@
 #endif
     }
-
-    WinLock::WinLock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = new CRITICAL_SECTION;
-      InitializeCriticalSection(lock);
-      _repr = lock;
-#endif
-    }
-    
-    WinLock::~WinLock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      DeleteCriticalSection(lock);
-      delete lock;
-#endif
-    }
-
-    void WinLock::lock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      EnterCriticalSection(lock);
-#endif
-    }
-
-    void WinLock::unlock() {
-#ifdef WIN32
-      CRITICAL_SECTION *lock = static_cast<CRITICAL_SECTION*>(_repr);
-      LeaveCriticalSection(lock);
-#endif
-    }
   }
 }
Index: lemon/bits/windows.h
===================================================================
--- lemon/bits/windows.h	(revision 979)
+++ lemon/bits/windows.h	(revision 529)
@@ -29,14 +29,4 @@
     std::string getWinFormattedDate();
     int getWinRndSeed();
-
-    class WinLock {
-    public:
-      WinLock();
-      ~WinLock();
-      void lock();
-      void unlock();
-    private:
-      void *_repr;
-    };
   }
 }
Index: lemon/bucket_heap.h
===================================================================
--- lemon/bucket_heap.h	(revision 877)
+++ lemon/bucket_heap.h	(revision 683)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,7 +20,7 @@
 #define LEMON_BUCKET_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Bucket heap implementation.
+///\brief Bucket Heap implementation.
 
 #include <vector>
@@ -54,39 +54,33 @@
   }
 
-  /// \ingroup heaps
-  ///
-  /// \brief Bucket heap data structure.
-  ///
-  /// This class implements the \e bucket \e heap data structure.
-  /// It practically conforms to the \ref concepts::Heap "heap concept",
-  /// but it has some limitations.
-  ///
-  /// The bucket heap is a very simple structure. It can store only
-  /// \c int priorities and it maintains a list of items for each priority
-  /// in the range <tt>[0..C)</tt>. So it should only be used when the
-  /// priorities are small. It is not intended to use as a Dijkstra heap.
-  ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
-  /// The default is \e min-heap. If this parameter is set to \c false,
-  /// then the comparison is reversed, so the top(), prio() and pop()
-  /// functions deal with the item having maximum priority instead of the
-  /// minimum.
-  ///
-  /// \sa SimpleBucketHeap
+  /// \ingroup auxdat
+  ///
+  /// \brief A Bucket Heap implementation.
+  ///
+  /// This class implements the \e bucket \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. The bucket heap is very simple implementation, it can store
+  /// only integer priorities and it stores for each priority in the
+  /// \f$ [0..C) \f$ range a list of items. So it should be used only when
+  /// the priorities are small. It is not intended to use as dijkstra heap.
+  ///
+  /// \param IM A read and write Item int map, used internally
+  /// to handle the cross references.
+  /// \param MIN If the given parameter is false then instead of the
+  /// minimum value the maximum can be retrivied with the top() and
+  /// prio() member functions.
   template <typename IM, bool MIN = true>
   class BucketHeap {
 
   public:
-
-    /// Type of the item-int map.
+    /// \e
+    typedef typename IM::Key Item;
+    /// \e
+    typedef int Prio;
+    /// \e
+    typedef std::pair<Item, Prio> Pair;
+    /// \e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
 
   private:
@@ -96,8 +90,8 @@
   public:
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -111,30 +105,28 @@
 
   public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
     explicit BucketHeap(ItemIntMap &map) : _iim(map), _minimum(0) {}
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// The number of items stored in the heap.
+    ///
+    /// \brief Returns the number of items stored in the heap.
     int size() const { return _data.size(); }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    /// Returns \c true if and only if the heap stores no items.
     bool empty() const { return _data.empty(); }
 
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
+    /// \brief Make empty this heap.
+    ///
+    /// Make empty this heap. It does not change the cross reference
+    /// map.  If you want to reuse 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.
     void clear() {
       _data.clear(); _first.clear(); _minimum = 0;
@@ -143,5 +135,5 @@
   private:
 
-    void relocateLast(int idx) {
+    void relocate_last(int idx) {
       if (idx + 1 < int(_data.size())) {
         _data[idx] = _data.back();
@@ -183,11 +175,8 @@
 
   public:
-
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \c p.first to the heap with priority \c p.second.
     /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair& p) {
       push(p.first, p.second);
@@ -196,9 +185,7 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) {
       int idx = _data.size();
@@ -211,8 +198,8 @@
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       while (_first[_minimum] == -1) {
@@ -222,8 +209,8 @@
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
@@ -233,7 +220,7 @@
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -244,25 +231,25 @@
       _iim[_data[idx].item] = -2;
       unlace(idx);
-      relocateLast(idx);
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
+      relocate_last(idx);
+    }
+
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap, if \c i was
+    /// already stored in the heap.
+    /// \param i The item to erase.
     void erase(const Item &i) {
       int idx = _iim[i];
       _iim[_data[idx].item] = -2;
       unlace(idx);
-      relocateLast(idx);
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
+      relocate_last(idx);
+    }
+
+
+    /// \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 {
       int idx = _iim[i];
@@ -270,10 +257,9 @@
     }
 
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
+    /// \brief \c i gets to the heap with priority \c p independently
+    /// if \c i was already there.
+    ///
+    /// This method calls \ref push(\c i, \c p) if \c i is not stored
+    /// in the heap and sets the priority of \c i to \c p otherwise.
     /// \param i The item.
     /// \param p The priority.
@@ -289,10 +275,11 @@
     }
 
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+    /// \brief Decreases the priority of \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.
     /// \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];
@@ -305,10 +292,11 @@
     }
 
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+    /// \brief Increases the priority of \c i to \c p.
+    ///
+    /// This method sets the priority of item \c i to \c p.
+    /// \pre \c i must be stored in the heap with priority at most \c
+    /// p relative to \c Compare.
     /// \param i The item.
     /// \param p The priority.
-    /// \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];
@@ -318,11 +306,11 @@
     }
 
-    /// \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.
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
@@ -332,9 +320,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -372,27 +360,21 @@
   }; // class BucketHeap
 
-  /// \ingroup heaps
-  ///
-  /// \brief Simplified bucket heap data structure.
+  /// \ingroup auxdat
+  ///
+  /// \brief A Simplified Bucket Heap implementation.
   ///
   /// This class implements a simplified \e bucket \e heap data
-  /// structure. It does not provide some functionality, but it is
-  /// faster and simpler than BucketHeap. The main difference is
-  /// that BucketHeap stores a doubly-linked list for each key while
-  /// this class stores only simply-linked lists. It supports erasing
-  /// only for the item having minimum priority and it does not support
-  /// key increasing and decreasing.
-  ///
-  /// Note that this implementation does not conform to the
-  /// \ref concepts::Heap "heap concept" due to the lack of some
-  /// functionality.
-  ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam MIN Indicate if the heap is a \e min-heap or a \e max-heap.
-  /// The default is \e min-heap. If this parameter is set to \c false,
-  /// then the comparison is reversed, so the top(), prio() and pop()
-  /// functions deal with the item having maximum priority instead of the
-  /// minimum.
+  /// structure.  It does not provide some functionality but it faster
+  /// and simplier data structure than the BucketHeap. The main
+  /// difference is that the BucketHeap stores for every key a double
+  /// linked list while this class stores just simple lists. In the
+  /// other way it does not support erasing each elements just the
+  /// minimal and it does not supports key increasing, decreasing.
+  ///
+  /// \param IM A read and write Item int map, used internally
+  /// to handle the cross references.
+  /// \param MIN If the given parameter is false then instead of the
+  /// minimum value the maximum can be retrivied with the top() and
+  /// prio() member functions.
   ///
   /// \sa BucketHeap
@@ -401,13 +383,8 @@
 
   public:
-
-    /// Type of the item-int map.
+    typedef typename IM::Key Item;
+    typedef int Prio;
+    typedef std::pair<Item, Prio> Pair;
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
 
   private:
@@ -417,8 +394,8 @@
   public:
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -433,30 +410,29 @@
   public:
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    /// \param map should be given to the constructor, since it is used
+    /// internally to handle the cross references. The value of the map
+    /// should be PRE_HEAP (-1) for each element.
     explicit SimpleBucketHeap(ItemIntMap &map)
       : _iim(map), _free(-1), _num(0), _minimum(0) {}
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
+    /// \brief Returns the number of items stored in the heap.
+    ///
+    /// The number of items stored in the heap.
     int size() const { return _num; }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \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 == 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.
+    /// \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.
     void clear() {
       _data.clear(); _first.clear(); _free = -1; _num = 0; _minimum = 0;
@@ -465,8 +441,6 @@
     /// \brief Insert a pair of item and priority into the heap.
     ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
+    /// Adds \c p.first to the heap with priority \c p.second.
     /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
     void push(const Pair& p) {
       push(p.first, p.second);
@@ -475,9 +449,7 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
     void push(const Item &i, const Prio &p) {
       int idx;
@@ -500,8 +472,8 @@
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       while (_first[_minimum] == -1) {
@@ -511,8 +483,8 @@
     }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       while (_first[_minimum] == -1) {
@@ -522,7 +494,7 @@
     }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority from the heap.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -538,13 +510,14 @@
     }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    /// \warning This operator is not a constant time function because
-    /// it scans the whole data structure to find the proper value.
+    /// \brief Returns the priority of \c i.
+    ///
+    /// This function returns the priority of item \c i.
+    /// \warning This operator is not a constant time function
+    /// because it scans the whole data structure to find the proper
+    /// value.
+    /// \pre \c i must be in the heap.
+    /// \param i The item.
     Prio operator[](const Item &i) const {
-      for (int k = 0; k < int(_first.size()); ++k) {
+      for (int k = 0; k < _first.size(); ++k) {
         int idx = _first[k];
         while (idx != -1) {
@@ -558,11 +531,11 @@
     }
 
-    /// \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.
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
Index: mon/capacity_scaling.h
===================================================================
--- lemon/capacity_scaling.h	(revision 985)
+++ 	(revision )
@@ -1,991 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_CAPACITY_SCALING_H
-#define LEMON_CAPACITY_SCALING_H
-
-/// \ingroup min_cost_flow_algs
-///
-/// \file
-/// \brief Capacity Scaling algorithm for finding a minimum cost flow.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/bin_heap.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of CapacityScaling algorithm.
-  ///
-  /// Default traits class of CapacityScaling algorithm.
-  /// \tparam GR Digraph type.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values. By default it is \c int.
-  /// \tparam C The number type used for costs and potentials.
-  /// By default it is the same as \c V.
-  template <typename GR, typename V = int, typename C = V>
-  struct CapacityScalingDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef V Value;
-    /// The type of the arc costs
-    typedef C Cost;
-
-    /// \brief The type of the heap used for internal Dijkstra computations.
-    ///
-    /// The type of the heap used for internal Dijkstra computations.
-    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept,
-    /// its priority type must be \c Cost and its cross reference type
-    /// must be \ref RangeMap "RangeMap<int>".
-    typedef BinHeap<Cost, RangeMap<int> > Heap;
-  };
-
-  /// \addtogroup min_cost_flow_algs
-  /// @{
-
-  /// \brief Implementation of the Capacity Scaling algorithm for
-  /// finding a \ref min_cost_flow "minimum cost flow".
-  ///
-  /// \ref CapacityScaling implements the capacity scaling version
-  /// of the successive shortest path algorithm for finding a
-  /// \ref min_cost_flow "minimum cost flow" \ref amo93networkflows,
-  /// \ref edmondskarp72theoretical. It is an efficient dual
-  /// solution method.
-  ///
-  /// Most of the parameters of the problem (except for the digraph)
-  /// can be given using separate functions, and the algorithm can be
-  /// executed using the \ref run() function. If some parameters are not
-  /// specified, then default values will be used.
-  ///
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref CapacityScalingDefaultTraits
-  /// "CapacityScalingDefaultTraits<GR, V, C>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-  ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning Capacity bounds and supply values must be integer, but
-  /// arc costs can be arbitrary real numbers.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
-#ifdef DOXYGEN
-  template <typename GR, typename V, typename C, typename TR>
-#else
-  template < typename GR, typename V = int, typename C = V,
-             typename TR = CapacityScalingDefaultTraits<GR, V, C> >
-#endif
-  class CapacityScaling
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef typename TR::Value Value;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// The type of the heap used for internal Dijkstra computations
-    typedef typename TR::Heap Heap;
-
-    /// The \ref CapacityScalingDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  public:
-
-    /// \brief Problem type constants for the \c run() function.
-    ///
-    /// Enum type containing the problem type constants that can be
-    /// returned by the \ref run() function of the algorithm.
-    enum ProblemType {
-      /// The problem has no feasible solution (flow).
-      INFEASIBLE,
-      /// The problem has optimal solution (i.e. it is feasible and
-      /// bounded), and the algorithm has found optimal flow and node
-      /// potentials (primal and dual solutions).
-      OPTIMAL,
-      /// The digraph contains an arc of negative cost and infinite
-      /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however, note that it could actually be bounded
-      /// over the feasible flows, but this algroithm cannot handle
-      /// these cases.
-      UNBOUNDED
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<Value> ValueVector;
-    typedef std::vector<Cost> CostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-  private:
-
-    // Data related to the underlying digraph
-    const GR &_graph;
-    int _node_num;
-    int _arc_num;
-    int _res_arc_num;
-    int _root;
-
-    // Parameters of the problem
-    bool _have_lower;
-    Value _sum_supply;
-
-    // Data structures for storing the digraph
-    IntNodeMap _node_id;
-    IntArcMap _arc_idf;
-    IntArcMap _arc_idb;
-    IntVector _first_out;
-    BoolVector _forward;
-    IntVector _source;
-    IntVector _target;
-    IntVector _reverse;
-
-    // Node and arc data
-    ValueVector _lower;
-    ValueVector _upper;
-    CostVector _cost;
-    ValueVector _supply;
-
-    ValueVector _res_cap;
-    CostVector _pi;
-    ValueVector _excess;
-    IntVector _excess_nodes;
-    IntVector _deficit_nodes;
-
-    Value _delta;
-    int _factor;
-    IntVector _pred;
-
-  public:
-
-    /// \brief Constant for infinite upper bounds (capacities).
-    ///
-    /// Constant for infinite upper bounds (capacities).
-    /// It is \c std::numeric_limits<Value>::infinity() if available,
-    /// \c std::numeric_limits<Value>::max() otherwise.
-    const Value INF;
-
-  private:
-
-    // Special implementation of the Dijkstra algorithm for finding
-    // shortest paths in the residual network of the digraph with
-    // respect to the reduced arc costs and modifying the node
-    // potentials according to the found distance labels.
-    class ResidualDijkstra
-    {
-    private:
-
-      int _node_num;
-      bool _geq;
-      const IntVector &_first_out;
-      const IntVector &_target;
-      const CostVector &_cost;
-      const ValueVector &_res_cap;
-      const ValueVector &_excess;
-      CostVector &_pi;
-      IntVector &_pred;
-
-      IntVector _proc_nodes;
-      CostVector _dist;
-
-    public:
-
-      ResidualDijkstra(CapacityScaling& cs) :
-        _node_num(cs._node_num), _geq(cs._sum_supply < 0),
-        _first_out(cs._first_out), _target(cs._target), _cost(cs._cost),
-        _res_cap(cs._res_cap), _excess(cs._excess), _pi(cs._pi),
-        _pred(cs._pred), _dist(cs._node_num)
-      {}
-
-      int run(int s, Value delta = 1) {
-        RangeMap<int> heap_cross_ref(_node_num, Heap::PRE_HEAP);
-        Heap heap(heap_cross_ref);
-        heap.push(s, 0);
-        _pred[s] = -1;
-        _proc_nodes.clear();
-
-        // Process nodes
-        while (!heap.empty() && _excess[heap.top()] > -delta) {
-          int u = heap.top(), v;
-          Cost d = heap.prio() + _pi[u], dn;
-          _dist[u] = heap.prio();
-          _proc_nodes.push_back(u);
-          heap.pop();
-
-          // Traverse outgoing residual arcs
-          int last_out = _geq ? _first_out[u+1] : _first_out[u+1] - 1;
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            if (_res_cap[a] < delta) continue;
-            v = _target[a];
-            switch (heap.state(v)) {
-              case Heap::PRE_HEAP:
-                heap.push(v, d + _cost[a] - _pi[v]);
-                _pred[v] = a;
-                break;
-              case Heap::IN_HEAP:
-                dn = d + _cost[a] - _pi[v];
-                if (dn < heap[v]) {
-                  heap.decrease(v, dn);
-                  _pred[v] = a;
-                }
-                break;
-              case Heap::POST_HEAP:
-                break;
-            }
-          }
-        }
-        if (heap.empty()) return -1;
-
-        // Update potentials of processed nodes
-        int t = heap.top();
-        Cost dt = heap.prio();
-        for (int i = 0; i < int(_proc_nodes.size()); ++i) {
-          _pi[_proc_nodes[i]] += _dist[_proc_nodes[i]] - dt;
-        }
-
-        return t;
-      }
-
-    }; //class ResidualDijkstra
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetHeapTraits : public Traits {
-      typedef T Heap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c Heap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c Heap
-    /// type, which is used for internal Dijkstra computations.
-    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept,
-    /// its priority type must be \c Cost and its cross reference type
-    /// must be \ref RangeMap "RangeMap<int>".
-    template <typename T>
-    struct SetHeap
-      : public CapacityScaling<GR, V, C, SetHeapTraits<T> > {
-      typedef  CapacityScaling<GR, V, C, SetHeapTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    CapacityScaling() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    CapacityScaling(const GR& graph) :
-      _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),
-      INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() :
-          std::numeric_limits<Value>::max())
-    {
-      // Check the number types
-      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
-        "The flow type of CapacityScaling must be signed");
-      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
-        "The cost type of CapacityScaling must be signed");
-
-      // Reset data structures
-      reset();
-    }
-
-    /// \name Parameters
-    /// The parameters of the algorithm can be specified using these
-    /// functions.
-
-    /// @{
-
-    /// \brief Set the lower bounds on the arcs.
-    ///
-    /// This function sets the lower bounds on the arcs.
-    /// If it is not used before calling \ref run(), the lower bounds
-    /// will be set to zero on all arcs.
-    ///
-    /// \param map An arc map storing the lower bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template <typename LowerMap>
-    CapacityScaling& lowerMap(const LowerMap& map) {
-      _have_lower = true;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _lower[_arc_idf[a]] = map[a];
-        _lower[_arc_idb[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the upper bounds (capacities) on the arcs.
-    ///
-    /// This function sets the upper bounds (capacities) on the arcs.
-    /// If it is not used before calling \ref run(), the upper bounds
-    /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
-    ///
-    /// \param map An arc map storing the upper bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename UpperMap>
-    CapacityScaling& upperMap(const UpperMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _upper[_arc_idf[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the costs of the arcs.
-    ///
-    /// This function sets the costs of the arcs.
-    /// If it is not used before calling \ref run(), the costs
-    /// will be set to \c 1 on all arcs.
-    ///
-    /// \param map An arc map storing the costs.
-    /// Its \c Value type must be convertible to the \c Cost type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename CostMap>
-    CapacityScaling& costMap(const CostMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _cost[_arc_idf[a]] =  map[a];
-        _cost[_arc_idb[a]] = -map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the supply values of the nodes.
-    ///
-    /// This function sets the supply values of the nodes.
-    /// If neither this function nor \ref stSupply() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// \param map A node map storing the supply values.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename SupplyMap>
-    CapacityScaling& supplyMap(const SupplyMap& map) {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _supply[_node_id[n]] = map[n];
-      }
-      return *this;
-    }
-
-    /// \brief Set single source and target nodes and a supply value.
-    ///
-    /// This function sets a single source node and a single target node
-    /// and the required flow value.
-    /// If neither this function nor \ref supplyMap() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
-    /// assigned to \c t and all other nodes have zero supply value.
-    ///
-    /// \param s The source node.
-    /// \param t The target node.
-    /// \param k The required amount of flow from node \c s to node \c t
-    /// (i.e. the supply of \c s and the demand of \c t).
-    ///
-    /// \return <tt>(*this)</tt>
-    CapacityScaling& stSupply(const Node& s, const Node& t, Value k) {
-      for (int i = 0; i != _node_num; ++i) {
-        _supply[i] = 0;
-      }
-      _supply[_node_id[s]] =  k;
-      _supply[_node_id[t]] = -k;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Execution control
-    /// The algorithm can be executed using \ref run().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    /// For example,
-    /// \code
-    ///   CapacityScaling<ListDigraph> cs(graph);
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
-    ///
-    /// \param factor The capacity scaling factor. It must be larger than
-    /// one to use scaling. If it is less or equal to one, then scaling
-    /// will be disabled.
-    ///
-    /// \return \c INFEASIBLE if no feasible flow exists,
-    /// \n \c OPTIMAL if the problem has optimal solution
-    /// (i.e. it is feasible and bounded), and the algorithm has found
-    /// optimal flow and node potentials (primal and dual solutions),
-    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
-    /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however, note that it could actually be
-    /// bounded over the feasible flows, but this algroithm cannot handle
-    /// these cases.
-    ///
-    /// \see ProblemType
-    /// \see resetParams(), reset()
-    ProblemType run(int factor = 4) {
-      _factor = factor;
-      ProblemType pt = init();
-      if (pt != OPTIMAL) return pt;
-      return start();
-    }
-
-    /// \brief Reset all the parameters that have been given before.
-    ///
-    /// This function resets all the paramaters that have been given
-    /// before using functions \ref lowerMap(), \ref upperMap(),
-    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// For example,
-    /// \code
-    ///   CapacityScaling<ListDigraph> cs(graph);
-    ///
-    ///   // First run
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    ///
-    ///   // Run again with modified cost map (resetParams() is not called,
-    ///   // so only the cost map have to be set again)
-    ///   cost[e] += 100;
-    ///   cs.costMap(cost).run();
-    ///
-    ///   // Run again from scratch using resetParams()
-    ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cs.resetParams();
-    ///   cs.upperMap(capacity).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CapacityScaling& resetParams() {
-      for (int i = 0; i != _node_num; ++i) {
-        _supply[i] = 0;
-      }
-      for (int j = 0; j != _res_arc_num; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _cost[j] = _forward[j] ? 1 : -1;
-      }
-      _have_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CapacityScaling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-      ++_node_num;
-
-      _first_out.resize(_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _supply.resize(_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _pi.resize(_node_num);
-      _excess.resize(_node_num);
-      _pred.resize(_node_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num - 1;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The \ref run() function must be called before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found flow.
-    ///
-    /// This function returns the total cost of the found flow.
-    /// Its complexity is O(e).
-    ///
-    /// \note The return type of the function can be specified as a
-    /// template parameter. For example,
-    /// \code
-    ///   cs.totalCost<double>();
-    /// \endcode
-    /// It is useful if the total cost cannot be stored in the \c Cost
-    /// type of the algorithm, which is the default return type of the
-    /// function.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename Number>
-    Number totalCost() const {
-      Number c = 0;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int i = _arc_idb[a];
-        c += static_cast<Number>(_res_cap[i]) *
-             (-static_cast<Number>(_cost[i]));
-      }
-      return c;
-    }
-
-#ifndef DOXYGEN
-    Cost totalCost() const {
-      return totalCost<Cost>();
-    }
-#endif
-
-    /// \brief Return the flow on the given arc.
-    ///
-    /// This function returns the flow on the given arc.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value flow(const Arc& a) const {
-      return _res_cap[_arc_idb[a]];
-    }
-
-    /// \brief Return the flow map (the primal solution).
-    ///
-    /// This function copies the flow value on each arc into the given
-    /// map. The \c Value type of the algorithm must be convertible to
-    /// the \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename FlowMap>
-    void flowMap(FlowMap &map) const {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        map.set(a, _res_cap[_arc_idb[a]]);
-      }
-    }
-
-    /// \brief Return the potential (dual value) of the given node.
-    ///
-    /// This function returns the potential (dual value) of the
-    /// given node.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Cost potential(const Node& n) const {
-      return _pi[_node_id[n]];
-    }
-
-    /// \brief Return the potential map (the dual solution).
-    ///
-    /// This function copies the potential (dual value) of each node
-    /// into the given map.
-    /// The \c Cost type of the algorithm must be convertible to the
-    /// \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename PotentialMap>
-    void potentialMap(PotentialMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map.set(n, _pi[_node_id[n]]);
-      }
-    }
-
-    /// @}
-
-  private:
-
-    // Initialize the algorithm
-    ProblemType init() {
-      if (_node_num <= 1) return INFEASIBLE;
-
-      // Check the sum of supply values
-      _sum_supply = 0;
-      for (int i = 0; i != _root; ++i) {
-        _sum_supply += _supply[i];
-      }
-      if (_sum_supply > 0) return INFEASIBLE;
-
-      // Initialize vectors
-      for (int i = 0; i != _root; ++i) {
-        _pi[i] = 0;
-        _excess[i] = _supply[i];
-      }
-
-      // Remove non-zero lower bounds
-      const Value MAX = std::numeric_limits<Value>::max();
-      int last_out;
-      if (_have_lower) {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j]) {
-              Value c = _lower[j];
-              if (c >= 0) {
-                _res_cap[j] = _upper[j] < MAX ? _upper[j] - c : INF;
-              } else {
-                _res_cap[j] = _upper[j] < MAX + c ? _upper[j] - c : INF;
-              }
-              _excess[i] -= c;
-              _excess[_target[j]] += c;
-            } else {
-              _res_cap[j] = 0;
-            }
-          }
-        }
-      } else {
-        for (int j = 0; j != _res_arc_num; ++j) {
-          _res_cap[j] = _forward[j] ? _upper[j] : 0;
-        }
-      }
-
-      // Handle negative costs
-      for (int i = 0; i != _root; ++i) {
-        last_out = _first_out[i+1] - 1;
-        for (int j = _first_out[i]; j != last_out; ++j) {
-          Value rc = _res_cap[j];
-          if (_cost[j] < 0 && rc > 0) {
-            if (rc >= MAX) return UNBOUNDED;
-            _excess[i] -= rc;
-            _excess[_target[j]] += rc;
-            _res_cap[j] = 0;
-            _res_cap[_reverse[j]] += rc;
-          }
-        }
-      }
-
-      // Handle GEQ supply type
-      if (_sum_supply < 0) {
-        _pi[_root] = 0;
-        _excess[_root] = -_sum_supply;
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = -_sum_supply + 1;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      } else {
-        _pi[_root] = 0;
-        _excess[_root] = 0;
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = 1;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      }
-
-      // Initialize delta value
-      if (_factor > 1) {
-        // With scaling
-        Value max_sup = 0, max_dem = 0, max_cap = 0;
-        for (int i = 0; i != _root; ++i) {
-          Value ex = _excess[i];
-          if ( ex > max_sup) max_sup =  ex;
-          if (-ex > max_dem) max_dem = -ex;
-          int last_out = _first_out[i+1] - 1;
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_res_cap[j] > max_cap) max_cap = _res_cap[j];
-          }
-        }
-        max_sup = std::min(std::min(max_sup, max_dem), max_cap);
-        for (_delta = 1; 2 * _delta <= max_sup; _delta *= 2) ;
-      } else {
-        // Without scaling
-        _delta = 1;
-      }
-
-      return OPTIMAL;
-    }
-
-    ProblemType start() {
-      // Execute the algorithm
-      ProblemType pt;
-      if (_delta > 1)
-        pt = startWithScaling();
-      else
-        pt = startWithoutScaling();
-
-      // Handle non-zero lower bounds
-      if (_have_lower) {
-        int limit = _first_out[_root];
-        for (int j = 0; j != limit; ++j) {
-          if (!_forward[j]) _res_cap[j] += _lower[j];
-        }
-      }
-
-      // Shift potentials if necessary
-      Cost pr = _pi[_root];
-      if (_sum_supply < 0 || pr > 0) {
-        for (int i = 0; i != _node_num; ++i) {
-          _pi[i] -= pr;
-        }
-      }
-
-      return pt;
-    }
-
-    // Execute the capacity scaling algorithm
-    ProblemType startWithScaling() {
-      // Perform capacity scaling phases
-      int s, t;
-      ResidualDijkstra _dijkstra(*this);
-      while (true) {
-        // Saturate all arcs not satisfying the optimality condition
-        int last_out;
-        for (int u = 0; u != _node_num; ++u) {
-          last_out = _sum_supply < 0 ?
-            _first_out[u+1] : _first_out[u+1] - 1;
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            int v = _target[a];
-            Cost c = _cost[a] + _pi[u] - _pi[v];
-            Value rc = _res_cap[a];
-            if (c < 0 && rc >= _delta) {
-              _excess[u] -= rc;
-              _excess[v] += rc;
-              _res_cap[a] = 0;
-              _res_cap[_reverse[a]] += rc;
-            }
-          }
-        }
-
-        // Find excess nodes and deficit nodes
-        _excess_nodes.clear();
-        _deficit_nodes.clear();
-        for (int u = 0; u != _node_num; ++u) {
-          Value ex = _excess[u];
-          if (ex >=  _delta) _excess_nodes.push_back(u);
-          if (ex <= -_delta) _deficit_nodes.push_back(u);
-        }
-        int next_node = 0, next_def_node = 0;
-
-        // Find augmenting shortest paths
-        while (next_node < int(_excess_nodes.size())) {
-          // Check deficit nodes
-          if (_delta > 1) {
-            bool delta_deficit = false;
-            for ( ; next_def_node < int(_deficit_nodes.size());
-                    ++next_def_node ) {
-              if (_excess[_deficit_nodes[next_def_node]] <= -_delta) {
-                delta_deficit = true;
-                break;
-              }
-            }
-            if (!delta_deficit) break;
-          }
-
-          // Run Dijkstra in the residual network
-          s = _excess_nodes[next_node];
-          if ((t = _dijkstra.run(s, _delta)) == -1) {
-            if (_delta > 1) {
-              ++next_node;
-              continue;
-            }
-            return INFEASIBLE;
-          }
-
-          // Augment along a shortest path from s to t
-          Value d = std::min(_excess[s], -_excess[t]);
-          int u = t;
-          int a;
-          if (d > _delta) {
-            while ((a = _pred[u]) != -1) {
-              if (_res_cap[a] < d) d = _res_cap[a];
-              u = _source[a];
-            }
-          }
-          u = t;
-          while ((a = _pred[u]) != -1) {
-            _res_cap[a] -= d;
-            _res_cap[_reverse[a]] += d;
-            u = _source[a];
-          }
-          _excess[s] -= d;
-          _excess[t] += d;
-
-          if (_excess[s] < _delta) ++next_node;
-        }
-
-        if (_delta == 1) break;
-        _delta = _delta <= _factor ? 1 : _delta / _factor;
-      }
-
-      return OPTIMAL;
-    }
-
-    // Execute the successive shortest path algorithm
-    ProblemType startWithoutScaling() {
-      // Find excess nodes
-      _excess_nodes.clear();
-      for (int i = 0; i != _node_num; ++i) {
-        if (_excess[i] > 0) _excess_nodes.push_back(i);
-      }
-      if (_excess_nodes.size() == 0) return OPTIMAL;
-      int next_node = 0;
-
-      // Find shortest paths
-      int s, t;
-      ResidualDijkstra _dijkstra(*this);
-      while ( _excess[_excess_nodes[next_node]] > 0 ||
-              ++next_node < int(_excess_nodes.size()) )
-      {
-        // Run Dijkstra in the residual network
-        s = _excess_nodes[next_node];
-        if ((t = _dijkstra.run(s)) == -1) return INFEASIBLE;
-
-        // Augment along a shortest path from s to t
-        Value d = std::min(_excess[s], -_excess[t]);
-        int u = t;
-        int a;
-        if (d > 1) {
-          while ((a = _pred[u]) != -1) {
-            if (_res_cap[a] < d) d = _res_cap[a];
-            u = _source[a];
-          }
-        }
-        u = t;
-        while ((a = _pred[u]) != -1) {
-          _res_cap[a] -= d;
-          _res_cap[_reverse[a]] += d;
-          u = _source[a];
-        }
-        _excess[s] -= d;
-        _excess[t] += d;
-      }
-
-      return OPTIMAL;
-    }
-
-  }; //class CapacityScaling
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_CAPACITY_SCALING_H
Index: lemon/cbc.cc
===================================================================
--- lemon/cbc.cc	(revision 989)
+++ lemon/cbc.cc	(revision 988)
@@ -90,16 +90,4 @@
   }
 
-  int CbcMip::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-    std::vector<int> indexes;
-    std::vector<Value> values;
-
-    for(ExprIterator it = b; it != e; ++it) {
-      indexes.push_back(it->first);
-      values.push_back(it->second);
-    }
-
-    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
-    return _prob->numberRows() - 1;
-  }
 
   void CbcMip::_eraseCol(int i) {
Index: lemon/cbc.h
===================================================================
--- lemon/cbc.h	(revision 877)
+++ lemon/cbc.h	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -63,5 +63,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
@@ -122,5 +121,5 @@
     int _message_level;
 
-
+    
 
   };
Index: lemon/circulation.h
===================================================================
--- lemon/circulation.h	(revision 877)
+++ lemon/circulation.h	(revision 688)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -60,6 +60,6 @@
     /// \brief The type of supply map.
     ///
-    /// The type of the map that stores the signed supply values of the
-    /// nodes.
+    /// The type of the map that stores the signed supply values of the 
+    /// nodes. 
     /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
     typedef SM SupplyMap;
@@ -73,9 +73,5 @@
     /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
     /// concept.
-#ifdef DOXYGEN
-    typedef GR::ArcMap<Value> FlowMap;
-#else
     typedef typename Digraph::template ArcMap<Value> FlowMap;
-#endif
 
     /// \brief Instantiates a FlowMap.
@@ -92,10 +88,7 @@
     /// The elevator type used by the algorithm.
     ///
-    /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
-    typedef lemon::Elevator<GR, GR::Node> Elevator;
-#else
+    /// \sa Elevator
+    /// \sa LinkedElevator
     typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
-#endif
 
     /// \brief Instantiates an Elevator.
@@ -142,5 +135,5 @@
      \geq sup(u) \quad \forall u\in V, \f]
      \f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A. \f]
-
+     
      The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be
      zero or negative in order to have a feasible solution (since the sum
@@ -152,5 +145,5 @@
      constraints have to be satisfied with equality, i.e. all demands
      have to be satisfied and all supplies have to be used.
-
+     
      If you need the opposite inequalities in the supply/demand constraints
      (i.e. the total demand is less than the total supply and all the demands
@@ -174,9 +167,4 @@
      \tparam SM The type of the supply map. The default map type is
      \ref concepts::Digraph::NodeMap "GR::NodeMap<UM::Value>".
-     \tparam TR The traits class that defines various types used by the
-     algorithm. By default, it is \ref CirculationDefaultTraits
-     "CirculationDefaultTraits<GR, LM, UM, SM>".
-     In most cases, this parameter should not be set directly,
-     consider to use the named template parameters instead.
   */
 #ifdef DOXYGEN
@@ -312,5 +300,5 @@
     /// able to automatically created by the algorithm (i.e. the
     /// digraph and the maximum level should be passed to it).
-    /// However, an external elevator object could also be passed to the
+    /// However an external elevator object could also be passed to the
     /// algorithm with the \ref elevator(Elevator&) "elevator()" function
     /// before calling \ref run() or \ref init().
@@ -338,5 +326,5 @@
     /// \param graph The digraph the algorithm runs on.
     /// \param lower The lower bounds for the flow values on the arcs.
-    /// \param upper The upper bounds (capacities) for the flow values
+    /// \param upper The upper bounds (capacities) for the flow values 
     /// on the arcs.
     /// \param supply The signed supply values of the nodes.
@@ -463,8 +451,7 @@
     }
 
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
     Circulation& tolerance(const Tolerance& tolerance) {
       _tol = tolerance;
@@ -474,6 +461,5 @@
     /// \brief Returns a const reference to the tolerance.
     ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
+    /// Returns a const reference to the tolerance.
     const Tolerance& tolerance() const {
       return _tol;
@@ -482,6 +468,6 @@
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call \ref run().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
+    /// If you need more control on the initial solution or the execution,
+    /// first you have to call one of the \ref init() functions, then
     /// the \ref start() function.
 
Index: lemon/clp.cc
===================================================================
--- lemon/clp.cc	(revision 989)
+++ lemon/clp.cc	(revision 988)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -76,17 +76,4 @@
   int ClpLp::_addRow() {
     _prob->addRow(0, 0, 0, -COIN_DBL_MAX, COIN_DBL_MAX);
-    return _prob->numberRows() - 1;
-  }
-
-  int ClpLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-    std::vector<int> indexes;
-    std::vector<Value> values;
-
-    for(ExprIterator it = b; it != e; ++it) {
-      indexes.push_back(it->first);
-      values.push_back(it->second);
-    }
-
-    _prob->addRow(values.size(), &indexes.front(), &values.front(), l, u);
     return _prob->numberRows() - 1;
   }
Index: lemon/clp.h
===================================================================
--- lemon/clp.h	(revision 877)
+++ lemon/clp.h	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -76,5 +76,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
@@ -139,5 +138,5 @@
 
     virtual void _messageLevel(MessageLevel);
-
+    
   public:
 
Index: lemon/concepts/digraph.h
===================================================================
--- lemon/concepts/digraph.h	(revision 877)
+++ lemon/concepts/digraph.h	(revision 580)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -36,38 +36,44 @@
     /// \brief Class describing the concept of directed graphs.
     ///
-    /// This class describes the common interface of all directed
-    /// graphs (digraphs).
+    /// This class describes the \ref concept "concept" of the
+    /// immutable directed digraphs.
     ///
-    /// Like all concept classes, it only provides an interface
-    /// without any sensible implementation. So any general algorithm for
-    /// directed graphs should compile with this class, but it will not
-    /// run properly, of course.
-    /// An actual digraph implementation like \ref ListDigraph or
-    /// \ref SmartDigraph may have additional functionality.
+    /// Note that actual digraph implementation like @ref ListDigraph or
+    /// @ref SmartDigraph may have several additional functionality.
     ///
-    /// \sa Graph
+    /// \sa concept
     class Digraph {
     private:
-      /// Diraphs are \e not copy constructible. Use DigraphCopy instead.
-      Digraph(const Digraph &) {}
-      /// \brief Assignment of a digraph to another one is \e not allowed.
-      /// Use DigraphCopy instead.
+      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+
+      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
+      ///
+      Digraph(const Digraph &) {};
+      ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
+      ///\e not allowed. Use DigraphCopy() instead.
+
+      ///Assignment of \ref Digraph "Digraph"s to another ones are
+      ///\e not allowed.  Use DigraphCopy() instead.
+
       void operator=(const Digraph &) {}
-
     public:
-      /// Default constructor.
+      ///\e
+
+      /// Defalult constructor.
+
+      /// Defalult constructor.
+      ///
       Digraph() { }
-
-      /// The node type of the digraph
+      /// Class for identifying a node of the digraph
 
       /// This class identifies a node of the digraph. It also serves
       /// as a base class of the node iterators,
-      /// thus they convert to this type.
+      /// thus they will convert to this type.
       class Node {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Node() { }
         /// Copy constructor.
@@ -77,37 +83,38 @@
         Node(const Node&) { }
 
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator to be invalid.
         /// \sa Invalid for more details.
         Node(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Node) const { return true; }
 
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Node n)
+        ///
         bool operator!=(Node) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the nodes; this order has nothing to do with the iteration
-        /// ordering of the nodes.
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Node) const { return false; }
-      };
-
-      /// Iterator class for the nodes.
-
-      /// This iterator goes through each node of the digraph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of nodes in a digraph \c g of type \c %Digraph like this:
+
+      };
+
+      /// This iterator goes through each node.
+
+      /// This iterator goes through each node.
+      /// Its usage is quite simple, for example you can count the number
+      /// of nodes in digraph \c g of type \c Digraph like this:
       ///\code
       /// int count=0;
@@ -118,6 +125,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         NodeIt() { }
         /// Copy constructor.
@@ -126,18 +133,20 @@
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// Initialize the iterator to be invalid.
         /// \sa Invalid for more details.
         NodeIt(Invalid) { }
         /// Sets the iterator to the first node.
 
-        /// Sets the iterator to the first node of the given digraph.
-        ///
-        explicit NodeIt(const Digraph&) { }
-        /// Sets the iterator to the given node.
-
-        /// Sets the iterator to the given node of the given digraph.
-        ///
+        /// Sets the iterator to the first node of \c g.
+        ///
+        NodeIt(const Digraph&) { }
+        /// Node -> NodeIt conversion.
+
+        /// Sets the iterator to the node of \c the digraph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         NodeIt(const Digraph&, const Node&) { }
         /// Next node.
@@ -149,5 +158,5 @@
 
 
-      /// The arc type of the digraph
+      /// Class for identifying an arc of the digraph
 
       /// This class identifies an arc of the digraph. It also serves
@@ -158,6 +167,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -166,48 +175,49 @@
         ///
         Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Arc(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Arc n)
+        ///
         bool operator!=(Arc) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the arcs; this order has nothing to do with the iteration
-        /// ordering of the arcs.
+        /// To allow the use of digraph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Arc) const { return false; }
       };
 
-      /// Iterator class for the outgoing arcs of a node.
+      /// This iterator goes trough the outgoing arcs of a node.
 
       /// This iterator goes trough the \e outgoing arcs of a certain node
       /// of a digraph.
-      /// Its usage is quite simple, for example, you can count the number
+      /// Its usage is quite simple, for example you can count the number
       /// of outgoing arcs of a node \c n
-      /// in a digraph \c g of type \c %Digraph as follows.
+      /// in digraph \c g of type \c Digraph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class OutArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
@@ -216,20 +226,21 @@
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
+        /// This constructor sets the iterator to the first outgoing arc.
+
+        /// This constructor sets the iterator to the first outgoing arc of
+        /// the node.
         OutArcIt(const Digraph&, const Node&) { }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// Arc -> OutArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         OutArcIt(const Digraph&, const Arc&) { }
-        /// Next outgoing arc
+        ///Next outgoing arc
 
         /// Assign the iterator to the next
@@ -238,21 +249,22 @@
       };
 
-      /// Iterator class for the incoming arcs of a node.
+      /// This iterator goes trough the incoming arcs of a node.
 
       /// This iterator goes trough the \e incoming arcs of a certain node
       /// of a digraph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of incoming arcs of a node \c n
-      /// in a digraph \c g of type \c %Digraph as follows.
+      /// Its usage is quite simple, for example you can count the number
+      /// of outgoing arcs of a node \c n
+      /// in digraph \c g of type \c Digraph as follows.
       ///\code
       /// int count=0;
-      /// for(Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for(Digraph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class InArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         InArcIt() { }
         /// Copy constructor.
@@ -261,34 +273,34 @@
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
+        /// This constructor sets the iterator to first incoming arc.
+
+        /// This constructor set the iterator to the first incoming arc of
+        /// the node.
         InArcIt(const Digraph&, const Node&) { }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// Arc -> InArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         InArcIt(const Digraph&, const Arc&) { }
         /// Next incoming arc
 
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
+        /// Assign the iterator to the next inarc of the corresponding node.
+        ///
         InArcIt& operator++() { return *this; }
       };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each arc of the digraph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of arcs in a digraph \c g of type \c %Digraph as follows:
+      /// This iterator goes through each arc.
+
+      /// This iterator goes through each arc of a digraph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of arcs in a digraph \c g of type \c Digraph as follows:
       ///\code
       /// int count=0;
-      /// for(Digraph::ArcIt a(g); a!=INVALID; ++a) ++count;
+      /// for(Digraph::ArcIt e(g); e!=INVALID; ++e) ++count;
       ///\endcode
       class ArcIt : public Arc {
@@ -296,6 +308,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         ArcIt() { }
         /// Copy constructor.
@@ -304,66 +316,56 @@
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         ArcIt(Invalid) { }
-        /// Sets the iterator to the first arc.
-
-        /// Sets the iterator to the first arc of the given digraph.
-        ///
-        explicit ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given digraph.
-        ///
+        /// This constructor sets the iterator to the first arc.
+
+        /// This constructor sets the iterator to the first arc of \c g.
+        ///@param g the digraph
+        ArcIt(const Digraph& g) { ignore_unused_variable_warning(g); }
+        /// Arc -> ArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         ArcIt(const Digraph&, const Arc&) { }
-        /// Next arc
+        ///Next arc
 
         /// Assign the iterator to the next arc.
-        ///
         ArcIt& operator++() { return *this; }
       };
-
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
+      ///Gives back the target node of an arc.
+
+      ///Gives back the target node of an arc.
+      ///
+      Node target(Arc) const { return INVALID; }
+      ///Gives back the source node of an arc.
+
+      ///Gives back the source node of an arc.
+      ///
       Node source(Arc) const { return INVALID; }
 
-      /// \brief The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
-      Node target(Arc) const { return INVALID; }
-
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
+      /// \brief Returns the ID of the node.
       int id(Node) const { return -1; }
 
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
+      /// \brief Returns the ID of the arc.
       int id(Arc) const { return -1; }
 
-      /// \brief The node with the given ID.
-      ///
-      /// Returns the node with the given ID.
-      /// \pre The argument should be a valid node ID in the digraph.
+      /// \brief Returns the node with the given ID.
+      ///
+      /// \pre The argument should be a valid node ID in the graph.
       Node nodeFromId(int) const { return INVALID; }
 
-      /// \brief The arc with the given ID.
-      ///
-      /// Returns the arc with the given ID.
-      /// \pre The argument should be a valid arc ID in the digraph.
+      /// \brief Returns the arc with the given ID.
+      ///
+      /// \pre The argument should be a valid arc ID in the graph.
       Arc arcFromId(int) const { return INVALID; }
 
-      /// \brief An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
+      /// \brief Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
 
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
+      /// \brief Returns an upper bound on the arc IDs.
       int maxArcId() const { return -1; }
 
@@ -391,49 +393,48 @@
       int maxId(Arc) const { return -1; }
 
-      /// \brief The opposite node on the arc.
-      ///
-      /// Returns the opposite node on the given arc.
-      Node oppositeNode(Node, Arc) const { return INVALID; }
-
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given outgoing arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node baseNode(OutArcIt) const { return INVALID; }
+      /// Gives back the base node of the iterator.
+      /// It is always the target of the pointed arc.
+      Node baseNode(const InArcIt&) const { return INVALID; }
 
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given outgoing arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node runningNode(OutArcIt) const { return INVALID; }
+      /// Gives back the running node of the iterator.
+      /// It is always the source of the pointed arc.
+      Node runningNode(const InArcIt&) const { return INVALID; }
 
       /// \brief The base node of the iterator.
       ///
-      /// Returns the base node of the given incomming arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node baseNode(InArcIt) const { return INVALID; }
+      /// Gives back the base node of the iterator.
+      /// It is always the source of the pointed arc.
+      Node baseNode(const OutArcIt&) const { return INVALID; }
 
       /// \brief The running node of the iterator.
       ///
-      /// Returns the running node of the given incomming arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node runningNode(InArcIt) const { return INVALID; }
-
-      /// \brief Standard graph map type for the nodes.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
+      /// Gives back the running node of the iterator.
+      /// It is always the target of the pointed arc.
+      Node runningNode(const OutArcIt&) const { return INVALID; }
+
+      /// \brief The opposite node on the given arc.
+      ///
+      /// Gives back the opposite node on the given arc.
+      Node oppositeNode(const Node&, const Arc&) const { return INVALID; }
+
+      /// \brief Reference map of the nodes to type \c T.
+      ///
+      /// Reference map of the nodes to type \c T.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&> {
       public:
 
-        /// Constructor
-        explicit NodeMap(const Digraph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Digraph&) { }
+        ///\e
         NodeMap(const Digraph&, T) { }
 
       private:
         ///Copy constructor
-        NodeMap(const NodeMap& nm) :
+        NodeMap(const NodeMap& nm) : 
           ReferenceMap<Node, T, T&, const T&>(nm) { }
         ///Assignment operator
@@ -445,17 +446,15 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&> {
       public:
 
-        /// Constructor
-        explicit ArcMap(const Digraph&) { }
-        /// Constructor with given initial value
+        ///\e
+        ArcMap(const Digraph&) { }
+        ///\e
         ArcMap(const Digraph&, T) { }
-
       private:
         ///Copy constructor
Index: lemon/concepts/graph.h
===================================================================
--- lemon/concepts/graph.h	(revision 877)
+++ lemon/concepts/graph.h	(revision 657)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,5 +19,5 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concept of undirected graphs.
+///\brief The concept of Undirected Graphs.
 
 #ifndef LEMON_CONCEPTS_GRAPH_H
@@ -25,6 +25,4 @@
 
 #include <lemon/concepts/graph_components.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concept_check.h>
 #include <lemon/core.h>
 
@@ -34,72 +32,61 @@
     /// \ingroup graph_concepts
     ///
-    /// \brief Class describing the concept of undirected graphs.
+    /// \brief Class describing the concept of Undirected Graphs.
     ///
-    /// This class describes the common interface of all undirected
-    /// graphs.
+    /// This class describes the common interface of all Undirected
+    /// Graphs.
     ///
-    /// Like all concept classes, it only provides an interface
-    /// without any sensible implementation. So any general algorithm for
-    /// undirected graphs should compile with this class, but it will not
+    /// As all concept describing classes it provides only interface
+    /// without any sensible implementation. So any algorithm for
+    /// undirected graph should compile with this class, but it will not
     /// run properly, of course.
-    /// An actual graph implementation like \ref ListGraph or
-    /// \ref SmartGraph may have additional functionality.
     ///
-    /// The undirected graphs also fulfill the concept of \ref Digraph
-    /// "directed graphs", since each edge can also be regarded as two
-    /// oppositely directed arcs.
-    /// Undirected graphs provide an Edge type for the undirected edges and
-    /// an Arc type for the directed arcs. The Arc type is convertible to
-    /// Edge or inherited from it, i.e. the corresponding edge can be
-    /// obtained from an arc.
-    /// EdgeIt and EdgeMap classes can be used for the edges, while ArcIt
-    /// and ArcMap classes can be used for the arcs (just like in digraphs).
-    /// Both InArcIt and OutArcIt iterates on the same edges but with
-    /// opposite direction. IncEdgeIt also iterates on the same edges
-    /// as OutArcIt and InArcIt, but it is not convertible to Arc,
-    /// only to Edge.
+    /// The LEMON undirected graphs also fulfill the concept of
+    /// directed graphs (\ref lemon::concepts::Digraph "Digraph
+    /// Concept"). Each edges can be seen as two opposite
+    /// directed arc and consequently the undirected graph can be
+    /// seen as the direceted graph of these directed arcs. The
+    /// Graph has the Edge inner class for the edges and
+    /// the Arc type for the directed arcs. The Arc type is
+    /// convertible to Edge or inherited from it so from a directed
+    /// arc we can get the represented edge.
     ///
-    /// In LEMON, each undirected edge has an inherent orientation.
-    /// Thus it can defined if an arc is forward or backward oriented in
-    /// an undirected graph with respect to this default oriantation of
-    /// the represented edge.
-    /// With the direction() and direct() functions the direction
-    /// of an arc can be obtained and set, respectively.
+    /// In the sense of the LEMON each edge has a default
+    /// direction (it should be in every computer implementation,
+    /// because the order of edge's nodes defines an
+    /// orientation). With the default orientation we can define that
+    /// the directed arc is forward or backward directed. With the \c
+    /// direction() and \c direct() function we can get the direction
+    /// of the directed arc and we can direct an edge.
     ///
-    /// Only nodes and edges can be added to or removed from an undirected
-    /// graph and the corresponding arcs are added or removed automatically.
-    ///
-    /// \sa Digraph
+    /// The EdgeIt is an iterator for the edges. We can use
+    /// the EdgeMap to map values for the edges. The InArcIt and
+    /// OutArcIt iterates on the same edges but with opposite
+    /// direction. The IncEdgeIt iterates also on the same edges
+    /// as the OutArcIt and InArcIt but it is not convertible to Arc just
+    /// to Edge.
     class Graph {
-    private:
-      /// Graphs are \e not copy constructible. Use DigraphCopy instead.
-      Graph(const Graph&) {}
-      /// \brief Assignment of a graph to another one is \e not allowed.
-      /// Use DigraphCopy instead.
-      void operator=(const Graph&) {}
-
     public:
-      /// Default constructor.
-      Graph() {}
-
-      /// \brief Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// Undirected graphs should be tagged with \c UndirectedTag.
-      ///
-      /// This tag helps the \c enable_if technics to make compile time
+      /// \brief The undirected graph should be tagged by the
+      /// UndirectedTag.
+      ///
+      /// The undirected graph should be tagged by the UndirectedTag. This
+      /// tag helps the enable_if technics to make compile time
       /// specializations for undirected graphs.
       typedef True UndirectedTag;
 
-      /// The node type of the graph
-
-      /// This class identifies a node of the graph. It also serves
-      /// as a base class of the node iterators,
-      /// thus they convert to this type.
+      /// \brief The base type of node iterators,
+      /// or in other words, the trivial node iterator.
+      ///
+      /// This is the base type of each node iterator,
+      /// thus each kind of node iterator converts to this.
+      /// More precisely each kind of node iterator should be inherited
+      /// from the trivial node iterator.
       class Node {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Node() { }
         /// Copy constructor.
@@ -109,27 +96,27 @@
         Node(const Node&) { }
 
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// This constructor initializes the iterator to be invalid.
         /// \sa Invalid for more details.
         Node(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Node) const { return true; }
 
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Node n)
+        ///
         bool operator!=(Node) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
         /// the items; this order has nothing to do with the iteration
         /// ordering of the items.
@@ -138,9 +125,9 @@
       };
 
-      /// Iterator class for the nodes.
-
-      /// This iterator goes through each node of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of nodes in a graph \c g of type \c %Graph like this:
+      /// This iterator goes through each node.
+
+      /// This iterator goes through each node.
+      /// Its usage is quite simple, for example you can count the number
+      /// of nodes in graph \c g of type \c Graph like this:
       ///\code
       /// int count=0;
@@ -151,6 +138,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         NodeIt() { }
         /// Copy constructor.
@@ -159,18 +146,20 @@
         ///
         NodeIt(const NodeIt& n) : Node(n) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
+        /// Invalid constructor \& conversion.
+
+        /// Initialize the iterator to be invalid.
         /// \sa Invalid for more details.
         NodeIt(Invalid) { }
         /// Sets the iterator to the first node.
 
-        /// Sets the iterator to the first node of the given digraph.
-        ///
-        explicit NodeIt(const Graph&) { }
-        /// Sets the iterator to the given node.
-
-        /// Sets the iterator to the given node of the given digraph.
-        ///
+        /// Sets the iterator to the first node of \c g.
+        ///
+        NodeIt(const Graph&) { }
+        /// Node -> NodeIt conversion.
+
+        /// Sets the iterator to the node of \c the graph pointed by
+        /// the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         NodeIt(const Graph&, const Node&) { }
         /// Next node.
@@ -182,15 +171,14 @@
 
 
-      /// The edge type of the graph
-
-      /// This class identifies an edge of the graph. It also serves
-      /// as a base class of the edge iterators,
-      /// thus they will convert to this type.
+      /// The base type of the edge iterators.
+
+      /// The base type of the edge iterators.
+      ///
       class Edge {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Edge() { }
         /// Copy constructor.
@@ -199,36 +187,36 @@
         ///
         Edge(const Edge&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Edge(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Edge) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Edge n)
+        ///
         bool operator!=(Edge) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the edges; this order has nothing to do with the iteration
-        /// ordering of the edges.
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Edge) const { return false; }
       };
 
-      /// Iterator class for the edges.
-
-      /// This iterator goes through each edge of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of edges in a graph \c g of type \c %Graph as follows:
+      /// This iterator goes through each edge.
+
+      /// This iterator goes through each edge of a graph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of edges in a graph \c g of type \c Graph as follows:
       ///\code
       /// int count=0;
@@ -239,6 +227,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         EdgeIt() { }
         /// Copy constructor.
@@ -247,33 +235,36 @@
         ///
         EdgeIt(const EdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         EdgeIt(Invalid) { }
-        /// Sets the iterator to the first edge.
-
-        /// Sets the iterator to the first edge of the given graph.
-        ///
-        explicit EdgeIt(const Graph&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
+        /// This constructor sets the iterator to the first edge.
+
+        /// This constructor sets the iterator to the first edge.
+        EdgeIt(const Graph&) { }
+        /// Edge -> EdgeIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the edge-set, the iteration order is the
+        /// same.
         EdgeIt(const Graph&, const Edge&) { }
         /// Next edge
 
         /// Assign the iterator to the next edge.
-        ///
         EdgeIt& operator++() { return *this; }
       };
 
-      /// Iterator class for the incident edges of a node.
-
-      /// This iterator goes trough the incident undirected edges
-      /// of a certain node of a graph.
-      /// Its usage is quite simple, for example, you can compute the
-      /// degree (i.e. the number of incident edges) of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// \brief This iterator goes trough the incident undirected
+      /// arcs of a node.
+      ///
+      /// This iterator goes trough the incident edges
+      /// of a certain node of a graph. You should assume that the
+      /// loop arcs will be iterated twice.
+      ///
+      /// Its usage is quite simple, for example you can compute the
+      /// degree (i.e. count the number of incident arcs of a node \c n
+      /// in graph \c g of type \c Graph as follows.
       ///
       ///\code
@@ -281,12 +272,10 @@
       /// for(Graph::IncEdgeIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
-      ///
-      /// \warning Loop edges will be iterated twice.
       class IncEdgeIt : public Edge {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         IncEdgeIt() { }
         /// Copy constructor.
@@ -295,37 +284,38 @@
         ///
         IncEdgeIt(const IncEdgeIt& e) : Edge(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         IncEdgeIt(Invalid) { }
-        /// Sets the iterator to the first incident edge.
-
-        /// Sets the iterator to the first incident edge of the given node.
-        ///
+        /// This constructor sets the iterator to first incident arc.
+
+        /// This constructor set the iterator to the first incident arc of
+        /// the node.
         IncEdgeIt(const Graph&, const Node&) { }
-        /// Sets the iterator to the given edge.
-
-        /// Sets the iterator to the given edge of the given graph.
-        ///
+        /// Edge -> IncEdgeIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         IncEdgeIt(const Graph&, const Edge&) { }
-        /// Next incident edge
-
-        /// Assign the iterator to the next incident edge
+        /// Next incident arc
+
+        /// Assign the iterator to the next incident arc
         /// of the corresponding node.
         IncEdgeIt& operator++() { return *this; }
       };
 
-      /// The arc type of the graph
-
-      /// This class identifies a directed arc of the graph. It also serves
-      /// as a base class of the arc iterators,
-      /// thus they will convert to this type.
+      /// The directed arc type.
+
+      /// The directed arc type. It can be converted to the
+      /// edge or it should be inherited from the undirected
+      /// edge.
       class Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the object to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         Arc() { }
         /// Copy constructor.
@@ -334,45 +324,41 @@
         ///
         Arc(const Arc&) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the object to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         Arc(Invalid) { }
         /// Equality operator
 
-        /// Equality operator.
-        ///
         /// Two iterators are equal if and only if they point to the
-        /// same object or both are \c INVALID.
+        /// same object or both are invalid.
         bool operator==(Arc) const { return true; }
         /// Inequality operator
 
-        /// Inequality operator.
+        /// \sa operator==(Arc n)
+        ///
         bool operator!=(Arc) const { return true; }
 
         /// Artificial ordering operator.
 
-        /// Artificial ordering operator.
-        ///
-        /// \note This operator only has to define some strict ordering of
-        /// the arcs; this order has nothing to do with the iteration
-        /// ordering of the arcs.
+        /// To allow the use of graph descriptors as key type in std::map or
+        /// similar associative container we require this.
+        ///
+        /// \note This operator only have to define some strict ordering of
+        /// the items; this order has nothing to do with the iteration
+        /// ordering of the items.
         bool operator<(Arc) const { return false; }
 
-        /// Converison to \c Edge
-
-        /// Converison to \c Edge.
-        ///
+        /// Converison to Edge
         operator Edge() const { return Edge(); }
       };
-
-      /// Iterator class for the arcs.
-
-      /// This iterator goes through each directed arc of the graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of arcs in a graph \c g of type \c %Graph as follows:
+      /// This iterator goes through each directed arc.
+
+      /// This iterator goes through each arc of a graph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of arcs in a graph \c g of type \c Graph as follows:
       ///\code
       /// int count=0;
-      /// for(Graph::ArcIt a(g); a!=INVALID; ++a) ++count;
+      /// for(Graph::ArcIt e(g); e!=INVALID; ++e) ++count;
       ///\endcode
       class ArcIt : public Arc {
@@ -380,6 +366,6 @@
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         ArcIt() { }
         /// Copy constructor.
@@ -388,43 +374,44 @@
         ///
         ArcIt(const ArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         ArcIt(Invalid) { }
-        /// Sets the iterator to the first arc.
-
-        /// Sets the iterator to the first arc of the given graph.
-        ///
-        explicit ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// This constructor sets the iterator to the first arc.
+
+        /// This constructor sets the iterator to the first arc of \c g.
+        ///@param g the graph
+        ArcIt(const Graph &g) { ignore_unused_variable_warning(g); }
+        /// Arc -> ArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         ArcIt(const Graph&, const Arc&) { }
-        /// Next arc
+        ///Next arc
 
         /// Assign the iterator to the next arc.
-        ///
         ArcIt& operator++() { return *this; }
       };
 
-      /// Iterator class for the outgoing arcs of a node.
-
-      /// This iterator goes trough the \e outgoing directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
+      /// This iterator goes trough the outgoing directed arcs of a node.
+
+      /// This iterator goes trough the \e outgoing arcs of a certain node
+      /// of a graph.
+      /// Its usage is quite simple, for example you can count the number
       /// of outgoing arcs of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// in graph \c g of type \c Graph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::OutArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for (Graph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class OutArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         OutArcIt() { }
         /// Copy constructor.
@@ -433,23 +420,26 @@
         ///
         OutArcIt(const OutArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         OutArcIt(Invalid) { }
-        /// Sets the iterator to the first outgoing arc.
-
-        /// Sets the iterator to the first outgoing arc of the given node.
-        ///
+        /// This constructor sets the iterator to the first outgoing arc.
+
+        /// This constructor sets the iterator to the first outgoing arc of
+        /// the node.
+        ///@param n the node
+        ///@param g the graph
         OutArcIt(const Graph& n, const Node& g) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
         }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// Arc -> OutArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         OutArcIt(const Graph&, const Arc&) { }
-        /// Next outgoing arc
+        ///Next outgoing arc
 
         /// Assign the iterator to the next
@@ -458,21 +448,22 @@
       };
 
-      /// Iterator class for the incoming arcs of a node.
-
-      /// This iterator goes trough the \e incoming directed arcs of a
-      /// certain node of a graph.
-      /// Its usage is quite simple, for example, you can count the number
-      /// of incoming arcs of a node \c n
-      /// in a graph \c g of type \c %Graph as follows.
+      /// This iterator goes trough the incoming directed arcs of a node.
+
+      /// This iterator goes trough the \e incoming arcs of a certain node
+      /// of a graph.
+      /// Its usage is quite simple, for example you can count the number
+      /// of outgoing arcs of a node \c n
+      /// in graph \c g of type \c Graph as follows.
       ///\code
       /// int count=0;
-      /// for (Digraph::InArcIt a(g, n); a!=INVALID; ++a) ++count;
+      /// for(Graph::InArcIt e(g, n); e!=INVALID; ++e) ++count;
       ///\endcode
+
       class InArcIt : public Arc {
       public:
         /// Default constructor
 
-        /// Default constructor.
-        /// \warning It sets the iterator to an undefined value.
+        /// @warning The default constructor sets the iterator
+        /// to an undefined value.
         InArcIt() { }
         /// Copy constructor.
@@ -481,33 +472,35 @@
         ///
         InArcIt(const InArcIt& e) : Arc(e) { }
-        /// %Invalid constructor \& conversion.
-
-        /// Initializes the iterator to be invalid.
-        /// \sa Invalid for more details.
+        /// Initialize the iterator to be invalid.
+
+        /// Initialize the iterator to be invalid.
+        ///
         InArcIt(Invalid) { }
-        /// Sets the iterator to the first incoming arc.
-
-        /// Sets the iterator to the first incoming arc of the given node.
-        ///
+        /// This constructor sets the iterator to first incoming arc.
+
+        /// This constructor set the iterator to the first incoming arc of
+        /// the node.
+        ///@param n the node
+        ///@param g the graph
         InArcIt(const Graph& g, const Node& n) {
           ignore_unused_variable_warning(n);
           ignore_unused_variable_warning(g);
         }
-        /// Sets the iterator to the given arc.
-
-        /// Sets the iterator to the given arc of the given graph.
-        ///
+        /// Arc -> InArcIt conversion
+
+        /// Sets the iterator to the value of the trivial iterator \c e.
+        /// This feature necessitates that each time we
+        /// iterate the arc-set, the iteration order is the same.
         InArcIt(const Graph&, const Arc&) { }
         /// Next incoming arc
 
-        /// Assign the iterator to the next
-        /// incoming arc of the corresponding node.
+        /// Assign the iterator to the next inarc of the corresponding node.
+        ///
         InArcIt& operator++() { return *this; }
       };
 
-      /// \brief Standard graph map type for the nodes.
-      ///
-      /// Standard graph map type for the nodes.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the nodes to type \c T.
+      ///
+      /// Reference map of the nodes to type \c T.
       template<class T>
       class NodeMap : public ReferenceMap<Node, T, T&, const T&>
@@ -515,7 +508,7 @@
       public:
 
-        /// Constructor
-        explicit NodeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        NodeMap(const Graph&) { }
+        ///\e
         NodeMap(const Graph&, T) { }
 
@@ -532,8 +525,7 @@
       };
 
-      /// \brief Standard graph map type for the arcs.
-      ///
-      /// Standard graph map type for the arcs.
-      /// It conforms to the ReferenceMap concept.
+      /// \brief Reference map of the arcs to type \c T.
+      ///
+      /// Reference map of the arcs to type \c T.
       template<class T>
       class ArcMap : public ReferenceMap<Arc, T, T&, const T&>
@@ -541,9 +533,8 @@
       public:
 
-        /// Constructor
-        explicit ArcMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        ArcMap(const Graph&) { }
+        ///\e
         ArcMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
@@ -558,8 +549,7 @@
       };
 
-      /// \brief Standard graph map type for the edges.
-      ///
-      /// Standard graph map type for the edges.
-      /// It conforms to the ReferenceMap concept.
+      /// Reference map of the edges to type \c T.
+
+      /// Reference map of the edges to type \c T.
       template<class T>
       class EdgeMap : public ReferenceMap<Edge, T, T&, const T&>
@@ -567,9 +557,8 @@
       public:
 
-        /// Constructor
-        explicit EdgeMap(const Graph&) { }
-        /// Constructor with given initial value
+        ///\e
+        EdgeMap(const Graph&) { }
+        ///\e
         EdgeMap(const Graph&, T) { }
-
       private:
         ///Copy constructor
@@ -584,121 +573,104 @@
       };
 
-      /// \brief The first node of the edge.
-      ///
-      /// Returns the first node of the given edge.
-      ///
-      /// Edges don't have source and target nodes, however, methods
-      /// u() and v() are used to query the two end-nodes of an edge.
-      /// The orientation of an edge that arises this way is called
-      /// the inherent direction, it is used to define the default
-      /// direction for the corresponding arcs.
+      /// \brief Direct the given edge.
+      ///
+      /// Direct the given edge. The returned arc source
+      /// will be the given node.
+      Arc direct(const Edge&, const Node&) const {
+        return INVALID;
+      }
+
+      /// \brief Direct the given edge.
+      ///
+      /// Direct the given edge. The returned arc
+      /// represents the given edge and the direction comes
+      /// from the bool parameter. The source of the edge and
+      /// the directed arc is the same when the given bool is true.
+      Arc direct(const Edge&, bool) const {
+        return INVALID;
+      }
+
+      /// \brief Returns true if the arc has default orientation.
+      ///
+      /// Returns whether the given directed arc is same orientation as
+      /// the corresponding edge's default orientation.
+      bool direction(Arc) const { return true; }
+
+      /// \brief Returns the opposite directed arc.
+      ///
+      /// Returns the opposite directed arc.
+      Arc oppositeArc(Arc) const { return INVALID; }
+
+      /// \brief Opposite node on an arc
+      ///
+      /// \return The opposite of the given node on the given edge.
+      Node oppositeNode(Node, Edge) const { return INVALID; }
+
+      /// \brief First node of the edge.
+      ///
+      /// \return The first node of the given edge.
+      ///
+      /// Naturally edges don't have direction and thus
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
       /// \sa v()
       /// \sa direction()
       Node u(Edge) const { return INVALID; }
 
-      /// \brief The second node of the edge.
-      ///
-      /// Returns the second node of the given edge.
-      ///
-      /// Edges don't have source and target nodes, however, methods
-      /// u() and v() are used to query the two end-nodes of an edge.
-      /// The orientation of an edge that arises this way is called
-      /// the inherent direction, it is used to define the default
-      /// direction for the corresponding arcs.
+      /// \brief Second node of the edge.
+      ///
+      /// \return The second node of the given edge.
+      ///
+      /// Naturally edges don't have direction and thus
+      /// don't have source and target node. However we use \c u() and \c v()
+      /// methods to query the two nodes of the arc. The direction of the
+      /// arc which arises this way is called the inherent direction of the
+      /// edge, and is used to define the "default" direction
+      /// of the directed versions of the arcs.
       /// \sa u()
       /// \sa direction()
       Node v(Edge) const { return INVALID; }
 
-      /// \brief The source node of the arc.
-      ///
-      /// Returns the source node of the given arc.
+      /// \brief Source node of the directed arc.
       Node source(Arc) const { return INVALID; }
 
-      /// \brief The target node of the arc.
-      ///
-      /// Returns the target node of the given arc.
+      /// \brief Target node of the directed arc.
       Node target(Arc) const { return INVALID; }
 
-      /// \brief The ID of the node.
-      ///
-      /// Returns the ID of the given node.
+      /// \brief Returns the id of the node.
       int id(Node) const { return -1; }
 
-      /// \brief The ID of the edge.
-      ///
-      /// Returns the ID of the given edge.
+      /// \brief Returns the id of the edge.
       int id(Edge) const { return -1; }
 
-      /// \brief The ID of the arc.
-      ///
-      /// Returns the ID of the given arc.
+      /// \brief Returns the id of the arc.
       int id(Arc) const { return -1; }
 
-      /// \brief The node with the given ID.
-      ///
-      /// Returns the node with the given ID.
-      /// \pre The argument should be a valid node ID in the graph.
+      /// \brief Returns the node with the given id.
+      ///
+      /// \pre The argument should be a valid node id in the graph.
       Node nodeFromId(int) const { return INVALID; }
 
-      /// \brief The edge with the given ID.
-      ///
-      /// Returns the edge with the given ID.
-      /// \pre The argument should be a valid edge ID in the graph.
+      /// \brief Returns the edge with the given id.
+      ///
+      /// \pre The argument should be a valid edge id in the graph.
       Edge edgeFromId(int) const { return INVALID; }
 
-      /// \brief The arc with the given ID.
-      ///
-      /// Returns the arc with the given ID.
-      /// \pre The argument should be a valid arc ID in the graph.
+      /// \brief Returns the arc with the given id.
+      ///
+      /// \pre The argument should be a valid arc id in the graph.
       Arc arcFromId(int) const { return INVALID; }
 
-      /// \brief An upper bound on the node IDs.
-      ///
-      /// Returns an upper bound on the node IDs.
+      /// \brief Returns an upper bound on the node IDs.
       int maxNodeId() const { return -1; }
 
-      /// \brief An upper bound on the edge IDs.
-      ///
-      /// Returns an upper bound on the edge IDs.
+      /// \brief Returns an upper bound on the edge IDs.
       int maxEdgeId() const { return -1; }
 
-      /// \brief An upper bound on the arc IDs.
-      ///
-      /// Returns an upper bound on the arc IDs.
+      /// \brief Returns an upper bound on the arc IDs.
       int maxArcId() const { return -1; }
-
-      /// \brief The direction of the arc.
-      ///
-      /// Returns \c true if the direction of the given arc is the same as
-      /// the inherent orientation of the represented edge.
-      bool direction(Arc) const { return true; }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc
-      /// represents the given edge and its direction comes
-      /// from the bool parameter. If it is \c true, then the direction
-      /// of the arc is the same as the inherent orientation of the edge.
-      Arc direct(Edge, bool) const {
-        return INVALID;
-      }
-
-      /// \brief Direct the edge.
-      ///
-      /// Direct the given edge. The returned arc represents the given
-      /// edge and its source node is the given node.
-      Arc direct(Edge, Node) const {
-        return INVALID;
-      }
-
-      /// \brief The oppositely directed arc.
-      ///
-      /// Returns the oppositely directed arc representing the same edge.
-      Arc oppositeArc(Arc) const { return INVALID; }
-
-      /// \brief The opposite node on the edge.
-      ///
-      /// Returns the opposite node on the given edge.
-      Node oppositeNode(Node, Edge) const { return INVALID; }
 
       void first(Node&) const {}
@@ -734,37 +706,45 @@
       int maxId(Arc) const { return -1; }
 
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incident edge iterator.
-      Node baseNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incident edge iterator.
-      Node runningNode(IncEdgeIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given outgoing arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node baseNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given outgoing arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node runningNode(OutArcIt) const { return INVALID; }
-
-      /// \brief The base node of the iterator.
-      ///
-      /// Returns the base node of the given incomming arc iterator
-      /// (i.e. the target node of the corresponding arc).
-      Node baseNode(InArcIt) const { return INVALID; }
-
-      /// \brief The running node of the iterator.
-      ///
-      /// Returns the running node of the given incomming arc iterator
-      /// (i.e. the source node of the corresponding arc).
-      Node runningNode(InArcIt) const { return INVALID; }
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node (the source in this case) of the iterator
+      Node baseNode(OutArcIt e) const {
+        return source(e);
+      }
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node (the target in this case) of the
+      /// iterator
+      Node runningNode(OutArcIt e) const {
+        return target(e);
+      }
+
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node (the target in this case) of the iterator
+      Node baseNode(InArcIt e) const {
+        return target(e);
+      }
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node (the source in this case) of the
+      /// iterator
+      Node runningNode(InArcIt e) const {
+        return source(e);
+      }
+
+      /// \brief Base node of the iterator
+      ///
+      /// Returns the base node of the iterator
+      Node baseNode(IncEdgeIt) const {
+        return INVALID;
+      }
+
+      /// \brief Running node of the iterator
+      ///
+      /// Returns the running node of the iterator
+      Node runningNode(IncEdgeIt) const {
+        return INVALID;
+      }
 
       template <typename _Graph>
Index: lemon/concepts/graph_components.h
===================================================================
--- lemon/concepts/graph_components.h	(revision 976)
+++ lemon/concepts/graph_components.h	(revision 975)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -19,5 +19,5 @@
 ///\ingroup graph_concepts
 ///\file
-///\brief The concepts of graph components.
+///\brief The concept of graph components.
 
 #ifndef LEMON_CONCEPTS_GRAPH_COMPONENTS_H
@@ -39,5 +39,5 @@
     /// \note This class is a template class so that we can use it to
     /// create graph skeleton classes. The reason for this is that \c Node
-    /// and \c Arc (or \c Edge) types should \e not derive from the same
+    /// and \c Arc (or \c Edge) types should \e not derive from the same 
     /// base class. For \c Node you should instantiate it with character
     /// \c 'n', for \c Arc with \c 'a' and for \c Edge with \c 'e'.
@@ -90,8 +90,8 @@
       ///
       /// This operator defines an ordering of the items.
-      /// It makes possible to use graph item types as key types in
+      /// It makes possible to use graph item types as key types in 
       /// associative containers (e.g. \c std::map).
       ///
-      /// \note This operator only has to define some strict ordering of
+      /// \note This operator only have to define some strict ordering of
       /// the items; this order has nothing to do with the iteration
       /// ordering of the items.
@@ -124,5 +124,5 @@
     /// This class describes the base interface of directed graph types.
     /// All digraph %concepts have to conform to this class.
-    /// It just provides types for nodes and arcs and functions
+    /// It just provides types for nodes and arcs and functions 
     /// to get the source and the target nodes of arcs.
     class BaseDigraphComponent {
@@ -432,5 +432,5 @@
     /// \brief Concept class for \c NodeIt, \c ArcIt and \c EdgeIt types.
     ///
-    /// This class describes the concept of \c NodeIt, \c ArcIt and
+    /// This class describes the concept of \c NodeIt, \c ArcIt and 
     /// \c EdgeIt subtypes of digraph and graph types.
     template <typename GR, typename Item>
@@ -472,5 +472,5 @@
       /// next item.
       GraphItemIt& operator++() { return *this; }
-
+ 
       /// \brief Equality operator
       ///
@@ -508,13 +508,13 @@
     };
 
-    /// \brief Concept class for \c InArcIt, \c OutArcIt and
+    /// \brief Concept class for \c InArcIt, \c OutArcIt and 
     /// \c IncEdgeIt types.
     ///
-    /// This class describes the concept of \c InArcIt, \c OutArcIt
+    /// This class describes the concept of \c InArcIt, \c OutArcIt 
     /// and \c IncEdgeIt subtypes of digraph and graph types.
     ///
     /// \note Since these iterator classes do not inherit from the same
     /// base class, there is an additional template parameter (selector)
-    /// \c sel. For \c InArcIt you should instantiate it with character
+    /// \c sel. For \c InArcIt you should instantiate it with character 
     /// \c 'i', for \c OutArcIt with \c 'o' and for \c IncEdgeIt with \c 'e'.
     template <typename GR,
@@ -537,8 +537,8 @@
       GraphIncIt(const GraphIncIt& it) : Item(it) {}
 
-      /// \brief Constructor that sets the iterator to the first
+      /// \brief Constructor that sets the iterator to the first 
       /// incoming or outgoing arc.
       ///
-      /// Constructor that sets the iterator to the first arc
+      /// Constructor that sets the iterator to the first arc 
       /// incoming to or outgoing from the given node.
       explicit GraphIncIt(const GR&, const Base&) {}
@@ -813,7 +813,7 @@
       /// \brief Return the first edge incident to the given node.
       ///
-      /// This function gives back the first edge incident to the given
+      /// This function gives back the first edge incident to the given 
       /// node. The bool parameter gives back the direction for which the
-      /// source node of the directed arc representing the edge is the
+      /// source node of the directed arc representing the edge is the 
       /// given node.
       void firstInc(Edge&, bool&, const Node&) const {}
@@ -822,5 +822,5 @@
       /// given node.
       ///
-      /// This function gives back the next edge incident to the given
+      /// This function gives back the next edge incident to the given 
       /// node. The bool parameter should be used as \c firstInc() use it.
       void nextInc(Edge&, bool&) const {}
@@ -1002,5 +1002,5 @@
     ///
     /// This class describes the concept of standard graph maps, i.e.
-    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and
+    /// the \c NodeMap, \c ArcMap and \c EdgeMap subtypes of digraph and 
     /// graph types, which can be used for associating data to graph items.
     /// The standard graph maps must conform to the ReferenceMap concept.
@@ -1057,5 +1057,5 @@
           _Map m1(g);
           _Map m2(g,t);
-
+          
           // Copy constructor
           // _Map m3(m);
@@ -1081,5 +1081,5 @@
     ///
     /// This class describes the interface of mappable directed graphs.
-    /// It extends \ref BaseDigraphComponent with the standard digraph
+    /// It extends \ref BaseDigraphComponent with the standard digraph 
     /// map classes, namely \c NodeMap and \c ArcMap.
     /// This concept is part of the Digraph concept.
@@ -1219,5 +1219,5 @@
     ///
     /// This class describes the interface of mappable undirected graphs.
-    /// It extends \ref MappableDigraphComponent with the standard graph
+    /// It extends \ref MappableDigraphComponent with the standard graph 
     /// map class for edges (\c EdgeMap).
     /// This concept is part of the Graph concept.
@@ -1305,5 +1305,5 @@
     ///
     /// This class describes the interface of extendable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for adding
+    /// It extends \ref BaseDigraphComponent with functions for adding 
     /// nodes and arcs to the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -1350,5 +1350,5 @@
     ///
     /// This class describes the interface of extendable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for adding
+    /// It extends \ref BaseGraphComponent with functions for adding 
     /// nodes and edges to the graph.
     /// This concept requires \ref AlterableGraphComponent.
@@ -1395,5 +1395,5 @@
     ///
     /// This class describes the interface of erasable directed graphs.
-    /// It extends \ref BaseDigraphComponent with functions for removing
+    /// It extends \ref BaseDigraphComponent with functions for removing 
     /// nodes and arcs from the digraph.
     /// This concept requires \ref AlterableDigraphComponent.
@@ -1408,5 +1408,5 @@
       /// \brief Erase a node from the digraph.
       ///
-      /// This function erases the given node from the digraph and all arcs
+      /// This function erases the given node from the digraph and all arcs 
       /// connected to the node.
       void erase(const Node&) {}
@@ -1435,5 +1435,5 @@
     ///
     /// This class describes the interface of erasable undirected graphs.
-    /// It extends \ref BaseGraphComponent with functions for removing
+    /// It extends \ref BaseGraphComponent with functions for removing 
     /// nodes and edges from the graph.
     /// This concept requires \ref AlterableGraphComponent.
Index: lemon/concepts/heap.h
===================================================================
--- lemon/concepts/heap.h	(revision 976)
+++ lemon/concepts/heap.h	(revision 975)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,11 +17,11 @@
  */
 
-#ifndef LEMON_CONCEPTS_HEAP_H
-#define LEMON_CONCEPTS_HEAP_H
-
 ///\ingroup concept
 ///\file
 ///\brief The concept of heaps.
 
+#ifndef LEMON_CONCEPTS_HEAP_H
+#define LEMON_CONCEPTS_HEAP_H
+
 #include <lemon/core.h>
 #include <lemon/concept_check.h>
@@ -36,25 +36,19 @@
     /// \brief The heap concept.
     ///
-    /// This concept class describes the main interface of heaps.
-    /// The various \ref heaps "heap structures" are efficient
-    /// implementations of the abstract data type \e priority \e queue.
-    /// They store items with specified values called \e priorities
-    /// in such a way that finding and removing the item with minimum
-    /// priority are efficient. The basic operations are adding and
-    /// erasing items, changing the priority of an item, etc.
+    /// Concept class describing the main interface of heaps. A \e heap
+    /// is a data structure for storing items with specified values called
+    /// \e priorities in such a way that finding the item with minimum
+    /// priority is efficient. In a heap one can change the priority of an
+    /// item, add or erase an item, etc.
     ///
-    /// Heaps are crucial in several algorithms, such as Dijkstra and Prim.
-    /// Any class that conforms to this concept can be used easily in such
-    /// algorithms.
-    ///
-    /// \tparam PR Type of the priorities of the items.
-    /// \tparam IM A read-writable item map with \c int values, used
+    /// \tparam PR Type of the priority of the items.
+    /// \tparam IM A read and writable item map with int values, used
     /// internally to handle the cross references.
-    /// \tparam CMP A functor class for comparing the priorities.
+    /// \tparam Comp A functor class for the ordering of the priorities.
     /// The default is \c std::less<PR>.
 #ifdef DOXYGEN
-    template <typename PR, typename IM, typename CMP>
+    template <typename PR, typename IM, typename Comp = std::less<PR> >
 #else
-    template <typename PR, typename IM, typename CMP = std::less<PR> >
+    template <typename PR, typename IM>
 #endif
     class Heap {
@@ -71,6 +65,7 @@
       ///
       /// Each item has a state associated to it. It can be "in heap",
-      /// "pre-heap" or "post-heap". The latter two are indifferent from the
-      /// heap's point of view, but may be useful to the user.
+      /// "pre heap" or "post heap". The later two are indifferent
+      /// from the point of view of the heap, but may be useful for
+      /// the user.
       ///
       /// The item-int map must be initialized in such way that it assigns
@@ -78,148 +73,99 @@
       enum State {
         IN_HEAP = 0,    ///< = 0. The "in heap" state constant.
-        PRE_HEAP = -1,  ///< = -1. The "pre-heap" state constant.
-        POST_HEAP = -2  ///< = -2. The "post-heap" state constant.
+        PRE_HEAP = -1,  ///< = -1. The "pre heap" state constant.
+        POST_HEAP = -2  ///< = -2. The "post heap" state constant.
       };
 
-      /// \brief Constructor.
-      ///
-      /// Constructor.
+      /// \brief The constructor.
+      ///
+      /// The constructor.
       /// \param map A map that assigns \c int values to keys of type
       /// \c Item. It is used internally by the heap implementations to
       /// handle the cross references. The assigned value must be
-      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
-#ifdef DOXYGEN
+      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
       explicit Heap(ItemIntMap &map) {}
-#else
-      explicit Heap(ItemIntMap&) {}
-#endif
-
-      /// \brief Constructor.
-      ///
-      /// Constructor.
-      /// \param map A map that assigns \c int values to keys of type
-      /// \c Item. It is used internally by the heap implementations to
-      /// handle the cross references. The assigned value must be
-      /// \c PRE_HEAP (<tt>-1</tt>) for each item.
-      /// \param comp The function object used for comparing the priorities.
-#ifdef DOXYGEN
-      explicit Heap(ItemIntMap &map, const CMP &comp) {}
-#else
-      explicit Heap(ItemIntMap&, const CMP&) {}
-#endif
 
       /// \brief The number of items stored in the heap.
       ///
-      /// This function returns the number of items stored in the heap.
+      /// Returns the number of items stored in the heap.
       int size() const { return 0; }
 
-      /// \brief Check if the heap is empty.
-      ///
-      /// This function returns \c true if the heap is empty.
+      /// \brief Checks if the heap is empty.
+      ///
+      /// Returns \c true if the heap is empty.
       bool empty() const { return false; }
 
-      /// \brief Make the heap empty.
-      ///
-      /// This functon makes the heap empty.
-      /// It does not change the cross reference map. If you want to reuse
-      /// a heap that is not surely empty, you should first clear it and
-      /// then you should set the cross reference map to \c PRE_HEAP
-      /// for each item.
-      void clear() {}
-
-      /// \brief Insert an item into the heap with the given priority.
-      ///
-      /// This function inserts the given item into the heap with the
-      /// given priority.
+      /// \brief Makes the heap empty.
+      ///
+      /// Makes the heap empty.
+      void clear();
+
+      /// \brief Inserts an item into the heap with the given priority.
+      ///
+      /// Inserts the given item into the heap with the given priority.
       /// \param i The item to insert.
       /// \param p The priority of the item.
-      /// \pre \e i must not be stored in the heap.
-#ifdef DOXYGEN
       void push(const Item &i, const Prio &p) {}
-#else
-      void push(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Return the item having minimum priority.
-      ///
-      /// This function returns the item having minimum priority.
+
+      /// \brief Returns the item having minimum priority.
+      ///
+      /// Returns the item having minimum priority.
       /// \pre The heap must be non-empty.
-      Item top() const { return Item(); }
+      Item top() const {}
 
       /// \brief The minimum priority.
       ///
-      /// This function returns the minimum priority.
+      /// Returns the minimum priority.
       /// \pre The heap must be non-empty.
-      Prio prio() const { return Prio(); }
-
-      /// \brief Remove the item having minimum priority.
-      ///
-      /// This function removes the item having minimum priority.
+      Prio prio() const {}
+
+      /// \brief Removes the item having minimum priority.
+      ///
+      /// Removes the item having minimum priority.
       /// \pre The heap must be non-empty.
       void pop() {}
 
-      /// \brief Remove the given item from the heap.
-      ///
-      /// This function removes the given item from the heap if it is
-      /// already stored.
+      /// \brief Removes an item from the heap.
+      ///
+      /// Removes the given item from the heap if it is already stored.
       /// \param i The item to delete.
-      /// \pre \e i must be in the heap.
-#ifdef DOXYGEN
       void erase(const Item &i) {}
-#else
-      void erase(const Item&) {}
-#endif
-
-      /// \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.
-#ifdef DOXYGEN
+
+      /// \brief The priority of an item.
+      ///
+      /// Returns the priority of the given item.
+      /// \param i The item.
+      /// \pre \c i must be in the heap.
       Prio operator[](const Item &i) const {}
-#else
-      Prio operator[](const Item&) const { return Prio(); }
-#endif
-
-      /// \brief Set the priority of an item or insert it, if it is
+
+      /// \brief Sets the priority of an item or inserts it, if it is
       /// not stored in the heap.
       ///
       /// This method sets the priority of the given item if it is
-      /// already stored in the heap. Otherwise it inserts the given
-      /// item into the heap with the given priority.
+      /// already stored in the heap.
+      /// Otherwise it inserts the given item with the given priority.
       ///
       /// \param i The item.
       /// \param p The priority.
-#ifdef DOXYGEN
       void set(const Item &i, const Prio &p) {}
-#else
-      void set(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Decrease the priority of an item to the given value.
-      ///
-      /// This function decreases the priority of an item to the given value.
+
+      /// \brief Decreases the priority of an item to the given value.
+      ///
+      /// Decreases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
-      /// \pre \e i must be stored in the heap with priority at least \e p.
-#ifdef DOXYGEN
+      /// \pre \c i must be stored in the heap with priority at least \c p.
       void decrease(const Item &i, const Prio &p) {}
-#else
-      void decrease(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Increase the priority of an item to the given value.
-      ///
-      /// This function increases the priority of an item to the given value.
+
+      /// \brief Increases the priority of an item to the given value.
+      ///
+      /// Increases the priority of an item to the given value.
       /// \param i The item.
       /// \param p The priority.
-      /// \pre \e i must be stored in the heap with priority at most \e p.
-#ifdef DOXYGEN
+      /// \pre \c i must be stored in the heap with priority at most \c p.
       void increase(const Item &i, const Prio &p) {}
-#else
-      void increase(const Item&, const Prio&) {}
-#endif
-
-      /// \brief Return the state of an item.
+
+      /// \brief Returns if an item is in, has already been in, or has
+      /// never been in the heap.
       ///
       /// This method returns \c PRE_HEAP if the given item has never
@@ -229,22 +175,14 @@
       /// to the heap again.
       /// \param i The item.
-#ifdef DOXYGEN
       State state(const Item &i) const {}
-#else
-      State state(const Item&) const { return PRE_HEAP; }
-#endif
-
-      /// \brief Set the state of an item in the heap.
-      ///
-      /// This function sets the state of the given item in the heap.
-      /// It can be used to manually clear the heap when it is important
-      /// to achive better time complexity.
+
+      /// \brief Sets the state of an item in the heap.
+      ///
+      /// Sets the state of the given item in the heap. It can be used
+      /// to manually clear the heap when it is important to achive the
+      /// better time complexity.
       /// \param i The item.
       /// \param st The state. It should not be \c IN_HEAP.
-#ifdef DOXYGEN
       void state(const Item& i, State st) {}
-#else
-      void state(const Item&, State) {}
-#endif
 
 
Index: lemon/concepts/path.h
===================================================================
--- lemon/concepts/path.h	(revision 976)
+++ lemon/concepts/path.h	(revision 975)
@@ -19,5 +19,5 @@
 ///\ingroup concept
 ///\file
-///\brief The concept of paths
+///\brief Classes for representing paths in digraphs.
 ///
 
@@ -39,20 +39,11 @@
     /// A skeleton structure for representing directed paths in a
     /// digraph.
-    /// In a sense, a path can be treated as a list of arcs.
-    /// LEMON path types just store this list. As a consequence, they cannot
-    /// enumerate the nodes on the path directly and a zero length path
-    /// cannot store its source node.
-    ///
-    /// The arcs of a path should be stored in the order of their directions,
-    /// i.e. the target node of each arc should be the same as the source
-    /// node of the next arc. This consistency could be checked using
-    /// \ref checkPath().
-    /// The source and target nodes of a (consistent) path can be obtained
-    /// using \ref pathSource() and \ref pathTarget().
-    ///
-    /// A path can be constructed from another path of any type using the
-    /// copy constructor or the assignment operator.
-    ///
     /// \tparam GR The digraph type in which the path is.
+    ///
+    /// In a sense, the path can be treated as a list of arcs. The
+    /// lemon path type stores just this list. As a consequence it
+    /// cannot enumerate the nodes in the path and the zero length
+    /// paths cannot store the source.
+    ///
     template <typename GR>
     class Path {
@@ -69,9 +60,9 @@
       Path() {}
 
-      /// \brief Template copy constructor
+      /// \brief Template constructor
       template <typename CPath>
       Path(const CPath& cpath) {}
 
-      /// \brief Template assigment operator
+      /// \brief Template assigment
       template <typename CPath>
       Path& operator=(const CPath& cpath) {
@@ -80,5 +71,5 @@
       }
 
-      /// Length of the path, i.e. the number of arcs on the path.
+      /// Length of the path ie. the number of arcs in the path.
       int length() const { return 0;}
 
@@ -89,7 +80,7 @@
       void clear() {}
 
-      /// \brief LEMON style iterator for enumerating the arcs of a path.
+      /// \brief LEMON style iterator for path arcs
       ///
-      /// LEMON style iterator class for enumerating the arcs of a path.
+      /// This class is used to iterate on the arcs of the paths.
       class ArcIt {
       public:
@@ -98,8 +89,8 @@
         /// Invalid constructor
         ArcIt(Invalid) {}
-        /// Sets the iterator to the first arc of the given path
+        /// Constructor for first arc
         ArcIt(const Path &) {}
 
-        /// Conversion to \c Arc
+        /// Conversion to Arc
         operator Arc() const { return INVALID; }
 
@@ -204,16 +195,22 @@
     ///
     /// A skeleton structure for path dumpers. The path dumpers are
-    /// the generalization of the paths, they can enumerate the arcs
-    /// of the path either in forward or in backward order.
-    /// These classes are typically not used directly, they are rather
-    /// used to be assigned to a real path type.
+    /// the generalization of the paths. The path dumpers can
+    /// enumerate the arcs of the path wheter in forward or in
+    /// backward order.  In most time these classes are not used
+    /// directly rather it used to assign a dumped class to a real
+    /// path type.
     ///
     /// The main purpose of this concept is that the shortest path
-    /// algorithms can enumerate the arcs easily in reverse order.
-    /// In LEMON, such algorithms give back a (reverse) path dumper that
-    /// can be assigned to a real path. The dumpers can be implemented as
+    /// algorithms can enumerate easily the arcs in reverse order.
+    /// If we would like to give back a real path from these
+    /// algorithms then we should create a temporarly path object. In
+    /// LEMON such algorithms gives back a path dumper what can
+    /// assigned to a real path and the dumpers can be implemented as
     /// an adaptor class to the predecessor map.
     ///
     /// \tparam GR The digraph type in which the path is.
+    ///
+    /// The paths can be constructed from any path type by a
+    /// template constructor or a template assignment operator.
     template <typename GR>
     class PathDumper {
@@ -225,5 +222,5 @@
       typedef typename Digraph::Arc Arc;
 
-      /// Length of the path, i.e. the number of arcs on the path.
+      /// Length of the path ie. the number of arcs in the path.
       int length() const { return 0;}
 
@@ -233,12 +230,13 @@
       /// \brief Forward or reverse dumping
       ///
-      /// If this tag is defined to be \c True, then reverse dumping
-      /// is provided in the path dumper. In this case, \c RevArcIt
-      /// iterator should be implemented instead of \c ArcIt iterator.
+      /// If the RevPathTag is defined and true then reverse dumping
+      /// is provided in the path dumper. In this case instead of the
+      /// ArcIt the RevArcIt iterator should be implemented in the
+      /// dumper.
       typedef False RevPathTag;
 
-      /// \brief LEMON style iterator for enumerating the arcs of a path.
+      /// \brief LEMON style iterator for path arcs
       ///
-      /// LEMON style iterator class for enumerating the arcs of a path.
+      /// This class is used to iterate on the arcs of the paths.
       class ArcIt {
       public:
@@ -247,8 +245,8 @@
         /// Invalid constructor
         ArcIt(Invalid) {}
-        /// Sets the iterator to the first arc of the given path
+        /// Constructor for first arc
         ArcIt(const PathDumper&) {}
 
-        /// Conversion to \c Arc
+        /// Conversion to Arc
         operator Arc() const { return INVALID; }
 
@@ -265,9 +263,8 @@
       };
 
-      /// \brief LEMON style iterator for enumerating the arcs of a path
-      /// in reverse direction.
+      /// \brief LEMON style iterator for path arcs
       ///
-      /// LEMON style iterator class for enumerating the arcs of a path
-      /// in reverse direction.
+      /// This class is used to iterate on the arcs of the paths in
+      /// reverse direction.
       class RevArcIt {
       public:
@@ -276,8 +273,8 @@
         /// Invalid constructor
         RevArcIt(Invalid) {}
-        /// Sets the iterator to the last arc of the given path
+        /// Constructor for first arc
         RevArcIt(const PathDumper &) {}
 
-        /// Conversion to \c Arc
+        /// Conversion to Arc
         operator Arc() const { return INVALID; }
 
Index: lemon/config.h.cmake
===================================================================
--- lemon/config.h.cmake	(revision 678)
+++ lemon/config.h.cmake	(revision 678)
@@ -0,0 +1,8 @@
+#define LEMON_VERSION "@PROJECT_VERSION@"
+#cmakedefine LEMON_HAVE_LONG_LONG 1
+#cmakedefine LEMON_HAVE_LP 1
+#cmakedefine LEMON_HAVE_MIP 1
+#cmakedefine LEMON_HAVE_GLPK 1
+#cmakedefine LEMON_HAVE_CPLEX 1
+#cmakedefine LEMON_HAVE_CLP 1
+#cmakedefine LEMON_HAVE_CBC 1
Index: lemon/config.h.in
===================================================================
--- lemon/config.h.in	(revision 981)
+++ lemon/config.h.in	(revision 678)
@@ -1,10 +1,26 @@
-#define LEMON_VERSION "@PROJECT_VERSION@"
-#cmakedefine LEMON_HAVE_LONG_LONG 1
-#cmakedefine LEMON_HAVE_LP 1
-#cmakedefine LEMON_HAVE_MIP 1
-#cmakedefine LEMON_HAVE_GLPK 1
-#cmakedefine LEMON_HAVE_CPLEX 1
-#cmakedefine LEMON_HAVE_CLP 1
-#cmakedefine LEMON_HAVE_CBC 1
-#cmakedefine LEMON_USE_PTHREAD 1
-#cmakedefine LEMON_USE_WIN32_THREADS 1
+/* The version string */
+#undef LEMON_VERSION
+
+/* Define to 1 if you have long long */
+#undef LEMON_HAVE_LONG_LONG
+
+/* Define to 1 if you have any LP solver. */
+#undef LEMON_HAVE_LP
+
+/* Define to 1 if you have any MIP solver. */
+#undef LEMON_HAVE_MIP
+
+/* Define to 1 if you have CPLEX. */
+#undef LEMON_HAVE_CPLEX
+
+/* Define to 1 if you have GLPK. */
+#undef LEMON_HAVE_GLPK
+
+/* Define to 1 if you have SOPLEX */
+#undef LEMON_HAVE_SOPLEX
+
+/* Define to 1 if you have CLP */
+#undef LEMON_HAVE_CLP
+
+/* Define to 1 if you have CBC */
+#undef LEMON_HAVE_CBC
Index: lemon/connectivity.h
===================================================================
--- lemon/connectivity.h	(revision 877)
+++ lemon/connectivity.h	(revision 648)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -259,5 +259,5 @@
   /// \return \c true if the digraph is strongly connected.
   /// \note By definition, the empty digraph is strongly connected.
-  ///
+  /// 
   /// \see countStronglyConnectedComponents(), stronglyConnectedComponents()
   /// \see connected()
@@ -311,5 +311,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of strongly connected components of a
+  /// \brief Count the number of strongly connected components of a 
   /// directed graph
   ///
@@ -745,5 +745,5 @@
   /// \brief Check whether an undirected graph is bi-node-connected.
   ///
-  /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is 
   /// bi-node-connected, i.e. any two edges are on same circle.
   ///
@@ -759,5 +759,5 @@
   /// \ingroup graph_properties
   ///
-  /// \brief Count the number of bi-node-connected components of an
+  /// \brief Count the number of bi-node-connected components of an 
   /// undirected graph.
   ///
@@ -813,5 +813,5 @@
   /// \retval compMap A writable edge map. The values will be set from 0
   /// to the number of the bi-node-connected components minus one. Each
-  /// value of the map will be set exactly once, and the values of a
+  /// value of the map will be set exactly once, and the values of a 
   /// certain component will be set continuously.
   /// \return The number of bi-node-connected components.
@@ -859,5 +859,5 @@
   ///
   /// \param graph The undirected graph.
-  /// \retval cutMap A writable node map. The values will be set to
+  /// \retval cutMap A writable node map. The values will be set to 
   /// \c true for the nodes that separate two or more components
   /// (exactly once for each cut node), and will not be changed for
@@ -1086,5 +1086,5 @@
   /// \brief Check whether an undirected graph is bi-edge-connected.
   ///
-  /// This function checks whether the given undirected graph is
+  /// This function checks whether the given undirected graph is 
   /// bi-edge-connected, i.e. any two nodes are connected with at least
   /// two edge-disjoint paths.
@@ -1193,5 +1193,5 @@
   ///
   /// This function finds the bi-edge-connected cut edges in the given
-  /// undirected graph.
+  /// undirected graph. 
   ///
   /// The bi-edge-connected components are the classes of an equivalence
@@ -1350,5 +1350,5 @@
   /// \param digraph The digraph.
   /// \retval order A readable and writable node map. The values will be
-  /// set from 0 to the number of the nodes in the digraph minus one.
+  /// set from 0 to the number of the nodes in the digraph minus one. 
   /// Each value of the map will be set exactly once, and the values will
   /// be set descending order.
Index: lemon/core.h
===================================================================
--- lemon/core.h	(revision 966)
+++ lemon/core.h	(revision 959)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -447,23 +447,4 @@
 
   }
-
-  /// \brief Check whether a graph is undirected.
-  ///
-  /// This function returns \c true if the given graph is undirected.
-#ifdef DOXYGEN
-  template <typename GR>
-  bool undirected(const GR& g) { return false; }
-#else
-  template <typename GR>
-  typename enable_if<UndirectedTagIndicator<GR>, bool>::type
-  undirected(const GR&) {
-    return true;
-  }
-  template <typename GR>
-  typename disable_if<UndirectedTagIndicator<GR>, bool>::type
-  undirected(const GR&) {
-    return false;
-  }
-#endif
 
   /// \brief Class to copy a digraph.
@@ -1261,6 +1242,5 @@
   protected:
 
-    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type
-    {
+    class AutoNodeMap : public ItemSetTraits<GR, Node>::template Map<Arc>::Type {
       typedef typename ItemSetTraits<GR, Node>::template Map<Arc>::Type Parent;
 
@@ -1301,5 +1281,5 @@
     };
 
-  protected:
+  protected: 
 
     const Digraph &_g;
Index: mon/cost_scaling.h
===================================================================
--- lemon/cost_scaling.h	(revision 938)
+++ 	(revision )
@@ -1,1587 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_COST_SCALING_H
-#define LEMON_COST_SCALING_H
-
-/// \ingroup min_cost_flow_algs
-/// \file
-/// \brief Cost scaling algorithm for finding a minimum cost flow.
-
-#include <vector>
-#include <deque>
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/maps.h>
-#include <lemon/math.h>
-#include <lemon/static_graph.h>
-#include <lemon/circulation.h>
-#include <lemon/bellman_ford.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of CostScaling algorithm.
-  ///
-  /// Default traits class of CostScaling algorithm.
-  /// \tparam GR Digraph type.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values. By default it is \c int.
-  /// \tparam C The number type used for costs and potentials.
-  /// By default it is the same as \c V.
-#ifdef DOXYGEN
-  template <typename GR, typename V = int, typename C = V>
-#else
-  template < typename GR, typename V = int, typename C = V,
-             bool integer = std::numeric_limits<C>::is_integer >
-#endif
-  struct CostScalingDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef V Value;
-    /// The type of the arc costs
-    typedef C Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename V, typename C>
-  struct CostScalingDefaultTraits<GR, V, C, true>
-  {
-    typedef GR Digraph;
-    typedef V Value;
-    typedef C Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-  };
-
-
-  /// \addtogroup min_cost_flow_algs
-  /// @{
-
-  /// \brief Implementation of the Cost Scaling algorithm for
-  /// finding a \ref min_cost_flow "minimum cost flow".
-  ///
-  /// \ref CostScaling implements a cost scaling algorithm that performs
-  /// push/augment and relabel operations for finding a \ref min_cost_flow
-  /// "minimum cost flow" \ref amo93networkflows, \ref goldberg90approximation,
-  /// \ref goldberg97efficient, \ref bunnagel98efficient.
-  /// It is a highly efficient primal-dual solution method, which
-  /// can be viewed as the generalization of the \ref Preflow
-  /// "preflow push-relabel" algorithm for the maximum flow problem.
-  ///
-  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
-  /// implementations available in LEMON for this problem.
-  ///
-  /// Most of the parameters of the problem (except for the digraph)
-  /// can be given using separate functions, and the algorithm can be
-  /// executed using the \ref run() function. If some parameters are not
-  /// specified, then default values will be used.
-  ///
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref CostScalingDefaultTraits
-  /// "CostScalingDefaultTraits<GR, V, C>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-  ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
-  /// be integer.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
-  ///
-  /// \note %CostScaling provides three different internal methods,
-  /// from which the most efficient one is used by default.
-  /// For more information, see \ref Method.
-#ifdef DOXYGEN
-  template <typename GR, typename V, typename C, typename TR>
-#else
-  template < typename GR, typename V = int, typename C = V,
-             typename TR = CostScalingDefaultTraits<GR, V, C> >
-#endif
-  class CostScaling
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef typename TR::Value Value;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The \ref CostScalingDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  public:
-
-    /// \brief Problem type constants for the \c run() function.
-    ///
-    /// Enum type containing the problem type constants that can be
-    /// returned by the \ref run() function of the algorithm.
-    enum ProblemType {
-      /// The problem has no feasible solution (flow).
-      INFEASIBLE,
-      /// The problem has optimal solution (i.e. it is feasible and
-      /// bounded), and the algorithm has found optimal flow and node
-      /// potentials (primal and dual solutions).
-      OPTIMAL,
-      /// The digraph contains an arc of negative cost and infinite
-      /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however, note that it could actually be bounded
-      /// over the feasible flows, but this algroithm cannot handle
-      /// these cases.
-      UNBOUNDED
-    };
-
-    /// \brief Constants for selecting the internal method.
-    ///
-    /// Enum type containing constants for selecting the internal method
-    /// for the \ref run() function.
-    ///
-    /// \ref CostScaling provides three internal methods that differ mainly
-    /// in their base operations, which are used in conjunction with the
-    /// relabel operation.
-    /// By default, the so called \ref PARTIAL_AUGMENT
-    /// "Partial Augment-Relabel" method is used, which turned out to be
-    /// the most efficient and the most robust on various test inputs.
-    /// However, the other methods can be selected using the \ref run()
-    /// function with the proper parameter.
-    enum Method {
-      /// Local push operations are used, i.e. flow is moved only on one
-      /// admissible arc at once.
-      PUSH,
-      /// Augment operations are used, i.e. flow is moved on admissible
-      /// paths from a node with excess to a node with deficit.
-      AUGMENT,
-      /// Partial augment operations are used, i.e. flow is moved on
-      /// admissible paths started from a node with excess, but the
-      /// lengths of these paths are limited. This method can be viewed
-      /// as a combined version of the previous two operations.
-      PARTIAL_AUGMENT
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<Value> ValueVector;
-    typedef std::vector<Cost> CostVector;
-    typedef std::vector<LargeCost> LargeCostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-  private:
-
-    template <typename KT, typename VT>
-    class StaticVectorMap {
-    public:
-      typedef KT Key;
-      typedef VT Value;
-
-      StaticVectorMap(std::vector<Value>& v) : _v(v) {}
-
-      const Value& operator[](const Key& key) const {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      Value& operator[](const Key& key) {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      void set(const Key& key, const Value& val) {
-        _v[StaticDigraph::id(key)] = val;
-      }
-
-    private:
-      std::vector<Value>& _v;
-    };
-
-    typedef StaticVectorMap<StaticDigraph::Arc, LargeCost> LargeCostArcMap;
-
-  private:
-
-    // Data related to the underlying digraph
-    const GR &_graph;
-    int _node_num;
-    int _arc_num;
-    int _res_node_num;
-    int _res_arc_num;
-    int _root;
-
-    // Parameters of the problem
-    bool _have_lower;
-    Value _sum_supply;
-    int _sup_node_num;
-
-    // Data structures for storing the digraph
-    IntNodeMap _node_id;
-    IntArcMap _arc_idf;
-    IntArcMap _arc_idb;
-    IntVector _first_out;
-    BoolVector _forward;
-    IntVector _source;
-    IntVector _target;
-    IntVector _reverse;
-
-    // Node and arc data
-    ValueVector _lower;
-    ValueVector _upper;
-    CostVector _scost;
-    ValueVector _supply;
-
-    ValueVector _res_cap;
-    LargeCostVector _cost;
-    LargeCostVector _pi;
-    ValueVector _excess;
-    IntVector _next_out;
-    std::deque<int> _active_nodes;
-
-    // Data for scaling
-    LargeCost _epsilon;
-    int _alpha;
-
-    IntVector _buckets;
-    IntVector _bucket_next;
-    IntVector _bucket_prev;
-    IntVector _rank;
-    int _max_rank;
-
-  public:
-
-    /// \brief Constant for infinite upper bounds (capacities).
-    ///
-    /// Constant for infinite upper bounds (capacities).
-    /// It is \c std::numeric_limits<Value>::infinity() if available,
-    /// \c std::numeric_limits<Value>::max() otherwise.
-    const Value INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type, which is used for internal computations in the algorithm.
-    /// \c Cost must be convertible to \c LargeCost.
-    template <typename T>
-    struct SetLargeCost
-      : public CostScaling<GR, V, C, SetLargeCostTraits<T> > {
-      typedef  CostScaling<GR, V, C, SetLargeCostTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    CostScaling() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    CostScaling(const GR& graph) :
-      _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),
-      INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() :
-          std::numeric_limits<Value>::max())
-    {
-      // Check the number types
-      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
-        "The flow type of CostScaling must be signed");
-      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
-        "The cost type of CostScaling must be signed");
-
-      // Reset data structures
-      reset();
-    }
-
-    /// \name Parameters
-    /// The parameters of the algorithm can be specified using these
-    /// functions.
-
-    /// @{
-
-    /// \brief Set the lower bounds on the arcs.
-    ///
-    /// This function sets the lower bounds on the arcs.
-    /// If it is not used before calling \ref run(), the lower bounds
-    /// will be set to zero on all arcs.
-    ///
-    /// \param map An arc map storing the lower bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template <typename LowerMap>
-    CostScaling& lowerMap(const LowerMap& map) {
-      _have_lower = true;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _lower[_arc_idf[a]] = map[a];
-        _lower[_arc_idb[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the upper bounds (capacities) on the arcs.
-    ///
-    /// This function sets the upper bounds (capacities) on the arcs.
-    /// If it is not used before calling \ref run(), the upper bounds
-    /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
-    ///
-    /// \param map An arc map storing the upper bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename UpperMap>
-    CostScaling& upperMap(const UpperMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _upper[_arc_idf[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the costs of the arcs.
-    ///
-    /// This function sets the costs of the arcs.
-    /// If it is not used before calling \ref run(), the costs
-    /// will be set to \c 1 on all arcs.
-    ///
-    /// \param map An arc map storing the costs.
-    /// Its \c Value type must be convertible to the \c Cost type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename CostMap>
-    CostScaling& costMap(const CostMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _scost[_arc_idf[a]] =  map[a];
-        _scost[_arc_idb[a]] = -map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the supply values of the nodes.
-    ///
-    /// This function sets the supply values of the nodes.
-    /// If neither this function nor \ref stSupply() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// \param map A node map storing the supply values.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename SupplyMap>
-    CostScaling& supplyMap(const SupplyMap& map) {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _supply[_node_id[n]] = map[n];
-      }
-      return *this;
-    }
-
-    /// \brief Set single source and target nodes and a supply value.
-    ///
-    /// This function sets a single source node and a single target node
-    /// and the required flow value.
-    /// If neither this function nor \ref supplyMap() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
-    /// assigned to \c t and all other nodes have zero supply value.
-    ///
-    /// \param s The source node.
-    /// \param t The target node.
-    /// \param k The required amount of flow from node \c s to node \c t
-    /// (i.e. the supply of \c s and the demand of \c t).
-    ///
-    /// \return <tt>(*this)</tt>
-    CostScaling& stSupply(const Node& s, const Node& t, Value k) {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      _supply[_node_id[s]] =  k;
-      _supply[_node_id[t]] = -k;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Execution control
-    /// The algorithm can be executed using \ref run().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    /// For example,
-    /// \code
-    ///   CostScaling<ListDigraph> cs(graph);
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
-    ///
-    /// \param method The internal method that will be used in the
-    /// algorithm. For more information, see \ref Method.
-    /// \param factor The cost scaling factor. It must be at least two.
-    ///
-    /// \return \c INFEASIBLE if no feasible flow exists,
-    /// \n \c OPTIMAL if the problem has optimal solution
-    /// (i.e. it is feasible and bounded), and the algorithm has found
-    /// optimal flow and node potentials (primal and dual solutions),
-    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
-    /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however, note that it could actually be
-    /// bounded over the feasible flows, but this algroithm cannot handle
-    /// these cases.
-    ///
-    /// \see ProblemType, Method
-    /// \see resetParams(), reset()
-    ProblemType run(Method method = PARTIAL_AUGMENT, int factor = 16) {
-      LEMON_ASSERT(factor >= 2, "The scaling factor must be at least 2");
-      _alpha = factor;
-      ProblemType pt = init();
-      if (pt != OPTIMAL) return pt;
-      start(method);
-      return OPTIMAL;
-    }
-
-    /// \brief Reset all the parameters that have been given before.
-    ///
-    /// This function resets all the paramaters that have been given
-    /// before using functions \ref lowerMap(), \ref upperMap(),
-    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// For example,
-    /// \code
-    ///   CostScaling<ListDigraph> cs(graph);
-    ///
-    ///   // First run
-    ///   cs.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    ///
-    ///   // Run again with modified cost map (resetParams() is not called,
-    ///   // so only the cost map have to be set again)
-    ///   cost[e] += 100;
-    ///   cs.costMap(cost).run();
-    ///
-    ///   // Run again from scratch using resetParams()
-    ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cs.resetParams();
-    ///   cs.upperMap(capacity).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CostScaling& resetParams() {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      int limit = _first_out[_root];
-      for (int j = 0; j != limit; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _scost[j] = _forward[j] ? 1 : -1;
-      }
-      for (int j = limit; j != _res_arc_num; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _scost[j] = 0;
-        _scost[_reverse[j]] = 0;
-      }
-      _have_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. By default, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CostScaling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_node_num = _node_num + 1;
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-
-      _first_out.resize(_res_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _scost.resize(_res_arc_num);
-      _supply.resize(_res_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _pi.resize(_res_node_num);
-      _excess.resize(_res_node_num);
-      _next_out.resize(_res_node_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_res_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The \ref run() function must be called before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found flow.
-    ///
-    /// This function returns the total cost of the found flow.
-    /// Its complexity is O(e).
-    ///
-    /// \note The return type of the function can be specified as a
-    /// template parameter. For example,
-    /// \code
-    ///   cs.totalCost<double>();
-    /// \endcode
-    /// It is useful if the total cost cannot be stored in the \c Cost
-    /// type of the algorithm, which is the default return type of the
-    /// function.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename Number>
-    Number totalCost() const {
-      Number c = 0;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int i = _arc_idb[a];
-        c += static_cast<Number>(_res_cap[i]) *
-             (-static_cast<Number>(_scost[i]));
-      }
-      return c;
-    }
-
-#ifndef DOXYGEN
-    Cost totalCost() const {
-      return totalCost<Cost>();
-    }
-#endif
-
-    /// \brief Return the flow on the given arc.
-    ///
-    /// This function returns the flow on the given arc.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value flow(const Arc& a) const {
-      return _res_cap[_arc_idb[a]];
-    }
-
-    /// \brief Return the flow map (the primal solution).
-    ///
-    /// This function copies the flow value on each arc into the given
-    /// map. The \c Value type of the algorithm must be convertible to
-    /// the \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename FlowMap>
-    void flowMap(FlowMap &map) const {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        map.set(a, _res_cap[_arc_idb[a]]);
-      }
-    }
-
-    /// \brief Return the potential (dual value) of the given node.
-    ///
-    /// This function returns the potential (dual value) of the
-    /// given node.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Cost potential(const Node& n) const {
-      return static_cast<Cost>(_pi[_node_id[n]]);
-    }
-
-    /// \brief Return the potential map (the dual solution).
-    ///
-    /// This function copies the potential (dual value) of each node
-    /// into the given map.
-    /// The \c Cost type of the algorithm must be convertible to the
-    /// \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename PotentialMap>
-    void potentialMap(PotentialMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map.set(n, static_cast<Cost>(_pi[_node_id[n]]));
-      }
-    }
-
-    /// @}
-
-  private:
-
-    // Initialize the algorithm
-    ProblemType init() {
-      if (_res_node_num <= 1) return INFEASIBLE;
-
-      // Check the sum of supply values
-      _sum_supply = 0;
-      for (int i = 0; i != _root; ++i) {
-        _sum_supply += _supply[i];
-      }
-      if (_sum_supply > 0) return INFEASIBLE;
-
-
-      // Initialize vectors
-      for (int i = 0; i != _res_node_num; ++i) {
-        _pi[i] = 0;
-        _excess[i] = _supply[i];
-      }
-
-      // Remove infinite upper bounds and check negative arcs
-      const Value MAX = std::numeric_limits<Value>::max();
-      int last_out;
-      if (_have_lower) {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j]) {
-              Value c = _scost[j] < 0 ? _upper[j] : _lower[j];
-              if (c >= MAX) return UNBOUNDED;
-              _excess[i] -= c;
-              _excess[_target[j]] += c;
-            }
-          }
-        }
-      } else {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j] && _scost[j] < 0) {
-              Value c = _upper[j];
-              if (c >= MAX) return UNBOUNDED;
-              _excess[i] -= c;
-              _excess[_target[j]] += c;
-            }
-          }
-        }
-      }
-      Value ex, max_cap = 0;
-      for (int i = 0; i != _res_node_num; ++i) {
-        ex = _excess[i];
-        _excess[i] = 0;
-        if (ex < 0) max_cap -= ex;
-      }
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_upper[j] >= MAX) _upper[j] = max_cap;
-      }
-
-      // Initialize the large cost vector and the epsilon parameter
-      _epsilon = 0;
-      LargeCost lc;
-      for (int i = 0; i != _root; ++i) {
-        last_out = _first_out[i+1];
-        for (int j = _first_out[i]; j != last_out; ++j) {
-          lc = static_cast<LargeCost>(_scost[j]) * _res_node_num * _alpha;
-          _cost[j] = lc;
-          if (lc > _epsilon) _epsilon = lc;
-        }
-      }
-      _epsilon /= _alpha;
-
-      // Initialize maps for Circulation and remove non-zero lower bounds
-      ConstMap<Arc, Value> low(0);
-      typedef typename Digraph::template ArcMap<Value> ValueArcMap;
-      typedef typename Digraph::template NodeMap<Value> ValueNodeMap;
-      ValueArcMap cap(_graph), flow(_graph);
-      ValueNodeMap sup(_graph);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sup[n] = _supply[_node_id[n]];
-      }
-      if (_have_lower) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          int j = _arc_idf[a];
-          Value c = _lower[j];
-          cap[a] = _upper[j] - c;
-          sup[_graph.source(a)] -= c;
-          sup[_graph.target(a)] += c;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          cap[a] = _upper[_arc_idf[a]];
-        }
-      }
-
-      _sup_node_num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (sup[n] > 0) ++_sup_node_num;
-      }
-
-      // Find a feasible flow using Circulation
-      Circulation<Digraph, ConstMap<Arc, Value>, ValueArcMap, ValueNodeMap>
-        circ(_graph, low, cap, sup);
-      if (!circ.flowMap(flow).run()) return INFEASIBLE;
-
-      // Set residual capacities and handle GEQ supply type
-      if (_sum_supply < 0) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-          sup[_graph.source(a)] -= fa;
-          sup[_graph.target(a)] += fa;
-        }
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          _excess[_node_id[n]] = sup[n];
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int u = _target[a];
-          int ra = _reverse[a];
-          _res_cap[a] = -_sum_supply + 1;
-          _res_cap[ra] = -_excess[u];
-          _cost[a] = 0;
-          _cost[ra] = 0;
-          _excess[u] = 0;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = 0;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      }
-
-      // Initialize data structures for buckets
-      _max_rank = _alpha * _res_node_num;
-      _buckets.resize(_max_rank);
-      _bucket_next.resize(_res_node_num + 1);
-      _bucket_prev.resize(_res_node_num + 1);
-      _rank.resize(_res_node_num + 1);
-
-      return OPTIMAL;
-    }
-
-    // Execute the algorithm and transform the results
-    void start(Method method) {
-      const int MAX_PARTIAL_PATH_LENGTH = 4;
-
-      switch (method) {
-        case PUSH:
-          startPush();
-          break;
-        case AUGMENT:
-          startAugment(_res_node_num - 1);
-          break;
-        case PARTIAL_AUGMENT:
-          startAugment(MAX_PARTIAL_PATH_LENGTH);
-          break;
-      }
-
-      // Compute node potentials (dual solution)
-      for (int i = 0; i != _res_node_num; ++i) {
-        _pi[i] = static_cast<Cost>(_pi[i] / (_res_node_num * _alpha));
-      }
-      bool optimal = true;
-      for (int i = 0; optimal && i != _res_node_num; ++i) {
-        LargeCost pi_i = _pi[i];
-        int last_out = _first_out[i+1];
-        for (int j = _first_out[i]; j != last_out; ++j) {
-          if (_res_cap[j] > 0 && _scost[j] + pi_i - _pi[_target[j]] < 0) {
-            optimal = false;
-            break;
-          }
-        }
-      }
-
-      if (!optimal) {
-        // Compute node potentials for the original costs with BellmanFord
-        // (if it is necessary)
-        typedef std::pair<int, int> IntPair;
-        StaticDigraph sgr;
-        std::vector<IntPair> arc_vec;
-        std::vector<LargeCost> cost_vec;
-        LargeCostArcMap cost_map(cost_vec);
-
-        arc_vec.clear();
-        cost_vec.clear();
-        for (int j = 0; j != _res_arc_num; ++j) {
-          if (_res_cap[j] > 0) {
-            int u = _source[j], v = _target[j];
-            arc_vec.push_back(IntPair(u, v));
-            cost_vec.push_back(_scost[j] + _pi[u] - _pi[v]);
-          }
-        }
-        sgr.build(_res_node_num, arc_vec.begin(), arc_vec.end());
-
-        typename BellmanFord<StaticDigraph, LargeCostArcMap>::Create
-          bf(sgr, cost_map);
-        bf.init(0);
-        bf.start();
-
-        for (int i = 0; i != _res_node_num; ++i) {
-          _pi[i] += bf.dist(sgr.node(i));
-        }
-      }
-
-      // Shift potentials to meet the requirements of the GEQ type
-      // optimality conditions
-      LargeCost max_pot = _pi[_root];
-      for (int i = 0; i != _res_node_num; ++i) {
-        if (_pi[i] > max_pot) max_pot = _pi[i];
-      }
-      if (max_pot != 0) {
-        for (int i = 0; i != _res_node_num; ++i) {
-          _pi[i] -= max_pot;
-        }
-      }
-
-      // Handle non-zero lower bounds
-      if (_have_lower) {
-        int limit = _first_out[_root];
-        for (int j = 0; j != limit; ++j) {
-          if (!_forward[j]) _res_cap[j] += _lower[j];
-        }
-      }
-    }
-
-    // Initialize a cost scaling phase
-    void initPhase() {
-      // Saturate arcs not satisfying the optimality condition
-      for (int u = 0; u != _res_node_num; ++u) {
-        int last_out = _first_out[u+1];
-        LargeCost pi_u = _pi[u];
-        for (int a = _first_out[u]; a != last_out; ++a) {
-          Value delta = _res_cap[a];
-          if (delta > 0) {
-            int v = _target[a];
-            if (_cost[a] + pi_u - _pi[v] < 0) {
-              _excess[u] -= delta;
-              _excess[v] += delta;
-              _res_cap[a] = 0;
-              _res_cap[_reverse[a]] += delta;
-            }
-          }
-        }
-      }
-
-      // Find active nodes (i.e. nodes with positive excess)
-      for (int u = 0; u != _res_node_num; ++u) {
-        if (_excess[u] > 0) _active_nodes.push_back(u);
-      }
-
-      // Initialize the next arcs
-      for (int u = 0; u != _res_node_num; ++u) {
-        _next_out[u] = _first_out[u];
-      }
-    }
-
-    // Price (potential) refinement heuristic
-    bool priceRefinement() {
-
-      // Stack for stroing the topological order
-      IntVector stack(_res_node_num);
-      int stack_top;
-
-      // Perform phases
-      while (topologicalSort(stack, stack_top)) {
-
-        // Compute node ranks in the acyclic admissible network and
-        // store the nodes in buckets
-        for (int i = 0; i != _res_node_num; ++i) {
-          _rank[i] = 0;
-        }
-        const int bucket_end = _root + 1;
-        for (int r = 0; r != _max_rank; ++r) {
-          _buckets[r] = bucket_end;
-        }
-        int top_rank = 0;
-        for ( ; stack_top >= 0; --stack_top) {
-          int u = stack[stack_top], v;
-          int rank_u = _rank[u];
-
-          LargeCost rc, pi_u = _pi[u];
-          int last_out = _first_out[u+1];
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            if (_res_cap[a] > 0) {
-              v = _target[a];
-              rc = _cost[a] + pi_u - _pi[v];
-              if (rc < 0) {
-                LargeCost nrc = static_cast<LargeCost>((-rc - 0.5) / _epsilon);
-                if (nrc < LargeCost(_max_rank)) {
-                  int new_rank_v = rank_u + static_cast<int>(nrc);
-                  if (new_rank_v > _rank[v]) {
-                    _rank[v] = new_rank_v;
-                  }
-                }
-              }
-            }
-          }
-
-          if (rank_u > 0) {
-            top_rank = std::max(top_rank, rank_u);
-            int bfirst = _buckets[rank_u];
-            _bucket_next[u] = bfirst;
-            _bucket_prev[bfirst] = u;
-            _buckets[rank_u] = u;
-          }
-        }
-
-        // Check if the current flow is epsilon-optimal
-        if (top_rank == 0) {
-          return true;
-        }
-
-        // Process buckets in top-down order
-        for (int rank = top_rank; rank > 0; --rank) {
-          while (_buckets[rank] != bucket_end) {
-            // Remove the first node from the current bucket
-            int u = _buckets[rank];
-            _buckets[rank] = _bucket_next[u];
-
-            // Search the outgoing arcs of u
-            LargeCost rc, pi_u = _pi[u];
-            int last_out = _first_out[u+1];
-            int v, old_rank_v, new_rank_v;
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                v = _target[a];
-                old_rank_v = _rank[v];
-
-                if (old_rank_v < rank) {
-
-                  // Compute the new rank of node v
-                  rc = _cost[a] + pi_u - _pi[v];
-                  if (rc < 0) {
-                    new_rank_v = rank;
-                  } else {
-                    LargeCost nrc = rc / _epsilon;
-                    new_rank_v = 0;
-                    if (nrc < LargeCost(_max_rank)) {
-                      new_rank_v = rank - 1 - static_cast<int>(nrc);
-                    }
-                  }
-
-                  // Change the rank of node v
-                  if (new_rank_v > old_rank_v) {
-                    _rank[v] = new_rank_v;
-
-                    // Remove v from its old bucket
-                    if (old_rank_v > 0) {
-                      if (_buckets[old_rank_v] == v) {
-                        _buckets[old_rank_v] = _bucket_next[v];
-                      } else {
-                        int pv = _bucket_prev[v], nv = _bucket_next[v];
-                        _bucket_next[pv] = nv;
-                        _bucket_prev[nv] = pv;
-                      }
-                    }
-
-                    // Insert v into its new bucket
-                    int nv = _buckets[new_rank_v];
-                    _bucket_next[v] = nv;
-                    _bucket_prev[nv] = v;
-                    _buckets[new_rank_v] = v;
-                  }
-                }
-              }
-            }
-
-            // Refine potential of node u
-            _pi[u] -= rank * _epsilon;
-          }
-        }
-
-      }
-
-      return false;
-    }
-
-    // Find and cancel cycles in the admissible network and
-    // determine topological order using DFS
-    bool topologicalSort(IntVector &stack, int &stack_top) {
-      const int MAX_CYCLE_CANCEL = 1;
-
-      BoolVector reached(_res_node_num, false);
-      BoolVector processed(_res_node_num, false);
-      IntVector pred(_res_node_num);
-      for (int i = 0; i != _res_node_num; ++i) {
-        _next_out[i] = _first_out[i];
-      }
-      stack_top = -1;
-
-      int cycle_cnt = 0;
-      for (int start = 0; start != _res_node_num; ++start) {
-        if (reached[start]) continue;
-
-        // Start DFS search from this start node
-        pred[start] = -1;
-        int tip = start, v;
-        while (true) {
-          // Check the outgoing arcs of the current tip node
-          reached[tip] = true;
-          LargeCost pi_tip = _pi[tip];
-          int a, last_out = _first_out[tip+1];
-          for (a = _next_out[tip]; a != last_out; ++a) {
-            if (_res_cap[a] > 0) {
-              v = _target[a];
-              if (_cost[a] + pi_tip - _pi[v] < 0) {
-                if (!reached[v]) {
-                  // A new node is reached
-                  reached[v] = true;
-                  pred[v] = tip;
-                  _next_out[tip] = a;
-                  tip = v;
-                  a = _next_out[tip];
-                  last_out = _first_out[tip+1];
-                  break;
-                }
-                else if (!processed[v]) {
-                  // A cycle is found
-                  ++cycle_cnt;
-                  _next_out[tip] = a;
-
-                  // Find the minimum residual capacity along the cycle
-                  Value d, delta = _res_cap[a];
-                  int u, delta_node = tip;
-                  for (u = tip; u != v; ) {
-                    u = pred[u];
-                    d = _res_cap[_next_out[u]];
-                    if (d <= delta) {
-                      delta = d;
-                      delta_node = u;
-                    }
-                  }
-
-                  // Augment along the cycle
-                  _res_cap[a] -= delta;
-                  _res_cap[_reverse[a]] += delta;
-                  for (u = tip; u != v; ) {
-                    u = pred[u];
-                    int ca = _next_out[u];
-                    _res_cap[ca] -= delta;
-                    _res_cap[_reverse[ca]] += delta;
-                  }
-
-                  // Check the maximum number of cycle canceling
-                  if (cycle_cnt >= MAX_CYCLE_CANCEL) {
-                    return false;
-                  }
-
-                  // Roll back search to delta_node
-                  if (delta_node != tip) {
-                    for (u = tip; u != delta_node; u = pred[u]) {
-                      reached[u] = false;
-                    }
-                    tip = delta_node;
-                    a = _next_out[tip] + 1;
-                    last_out = _first_out[tip+1];
-                    break;
-                  }
-                }
-              }
-            }
-          }
-
-          // Step back to the previous node
-          if (a == last_out) {
-            processed[tip] = true;
-            stack[++stack_top] = tip;
-            tip = pred[tip];
-            if (tip < 0) {
-              // Finish DFS from the current start node
-              break;
-            }
-            ++_next_out[tip];
-          }
-        }
-
-      }
-
-      return (cycle_cnt == 0);
-    }
-
-    // Global potential update heuristic
-    void globalUpdate() {
-      const int bucket_end = _root + 1;
-
-      // Initialize buckets
-      for (int r = 0; r != _max_rank; ++r) {
-        _buckets[r] = bucket_end;
-      }
-      Value total_excess = 0;
-      int b0 = bucket_end;
-      for (int i = 0; i != _res_node_num; ++i) {
-        if (_excess[i] < 0) {
-          _rank[i] = 0;
-          _bucket_next[i] = b0;
-          _bucket_prev[b0] = i;
-          b0 = i;
-        } else {
-          total_excess += _excess[i];
-          _rank[i] = _max_rank;
-        }
-      }
-      if (total_excess == 0) return;
-      _buckets[0] = b0;
-
-      // Search the buckets
-      int r = 0;
-      for ( ; r != _max_rank; ++r) {
-        while (_buckets[r] != bucket_end) {
-          // Remove the first node from the current bucket
-          int u = _buckets[r];
-          _buckets[r] = _bucket_next[u];
-
-          // Search the incomming arcs of u
-          LargeCost pi_u = _pi[u];
-          int last_out = _first_out[u+1];
-          for (int a = _first_out[u]; a != last_out; ++a) {
-            int ra = _reverse[a];
-            if (_res_cap[ra] > 0) {
-              int v = _source[ra];
-              int old_rank_v = _rank[v];
-              if (r < old_rank_v) {
-                // Compute the new rank of v
-                LargeCost nrc = (_cost[ra] + _pi[v] - pi_u) / _epsilon;
-                int new_rank_v = old_rank_v;
-                if (nrc < LargeCost(_max_rank)) {
-                  new_rank_v = r + 1 + static_cast<int>(nrc);
-                }
-
-                // Change the rank of v
-                if (new_rank_v < old_rank_v) {
-                  _rank[v] = new_rank_v;
-                  _next_out[v] = _first_out[v];
-
-                  // Remove v from its old bucket
-                  if (old_rank_v < _max_rank) {
-                    if (_buckets[old_rank_v] == v) {
-                      _buckets[old_rank_v] = _bucket_next[v];
-                    } else {
-                      int pv = _bucket_prev[v], nv = _bucket_next[v];
-                      _bucket_next[pv] = nv;
-                      _bucket_prev[nv] = pv;
-                    }
-                  }
-
-                  // Insert v into its new bucket
-                  int nv = _buckets[new_rank_v];
-                  _bucket_next[v] = nv;
-                  _bucket_prev[nv] = v;
-                  _buckets[new_rank_v] = v;
-                }
-              }
-            }
-          }
-
-          // Finish search if there are no more active nodes
-          if (_excess[u] > 0) {
-            total_excess -= _excess[u];
-            if (total_excess <= 0) break;
-          }
-        }
-        if (total_excess <= 0) break;
-      }
-
-      // Relabel nodes
-      for (int u = 0; u != _res_node_num; ++u) {
-        int k = std::min(_rank[u], r);
-        if (k > 0) {
-          _pi[u] -= _epsilon * k;
-          _next_out[u] = _first_out[u];
-        }
-      }
-    }
-
-    /// Execute the algorithm performing augment and relabel operations
-    void startAugment(int max_length) {
-      // Paramters for heuristics
-      const int PRICE_REFINEMENT_LIMIT = 2;
-      const double GLOBAL_UPDATE_FACTOR = 1.0;
-      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_global_update_limit = global_update_skip;
-
-      // Perform cost scaling phases
-      IntVector path;
-      BoolVector path_arc(_res_arc_num, false);
-      int relabel_cnt = 0;
-      int eps_phase_cnt = 0;
-      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
-                                        1 : _epsilon / _alpha )
-      {
-        ++eps_phase_cnt;
-
-        // Price refinement heuristic
-        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
-          if (priceRefinement()) continue;
-        }
-
-        // Initialize current phase
-        initPhase();
-
-        // Perform partial augment and relabel operations
-        while (true) {
-          // Select an active node (FIFO selection)
-          while (_active_nodes.size() > 0 &&
-                 _excess[_active_nodes.front()] <= 0) {
-            _active_nodes.pop_front();
-          }
-          if (_active_nodes.size() == 0) break;
-          int start = _active_nodes.front();
-
-          // Find an augmenting path from the start node
-          int tip = start;
-          while (int(path.size()) < max_length && _excess[tip] >= 0) {
-            int u;
-            LargeCost rc, min_red_cost = std::numeric_limits<LargeCost>::max();
-            LargeCost pi_tip = _pi[tip];
-            int last_out = _first_out[tip+1];
-            for (int a = _next_out[tip]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                u = _target[a];
-                rc = _cost[a] + pi_tip - _pi[u];
-                if (rc < 0) {
-                  path.push_back(a);
-                  _next_out[tip] = a;
-                  if (path_arc[a]) {
-                    goto augment;   // a cycle is found, stop path search
-                  }
-                  tip = u;
-                  path_arc[a] = true;
-                  goto next_step;
-                }
-                else if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
-              }
-            }
-
-            // Relabel tip node
-            if (tip != start) {
-              int ra = _reverse[path.back()];
-              min_red_cost =
-                std::min(min_red_cost, _cost[ra] + pi_tip - _pi[_target[ra]]);
-            }
-            last_out = _next_out[tip];
-            for (int a = _first_out[tip]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                rc = _cost[a] + pi_tip - _pi[_target[a]];
-                if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
-              }
-            }
-            _pi[tip] -= min_red_cost + _epsilon;
-            _next_out[tip] = _first_out[tip];
-            ++relabel_cnt;
-
-            // Step back
-            if (tip != start) {
-              int pa = path.back();
-              path_arc[pa] = false;
-              tip = _source[pa];
-              path.pop_back();
-            }
-
-          next_step: ;
-          }
-
-          // Augment along the found path (as much flow as possible)
-        augment:
-          Value delta;
-          int pa, u, v = start;
-          for (int i = 0; i != int(path.size()); ++i) {
-            pa = path[i];
-            u = v;
-            v = _target[pa];
-            path_arc[pa] = false;
-            delta = std::min(_res_cap[pa], _excess[u]);
-            _res_cap[pa] -= delta;
-            _res_cap[_reverse[pa]] += delta;
-            _excess[u] -= delta;
-            _excess[v] += delta;
-            if (_excess[v] > 0 && _excess[v] <= delta) {
-              _active_nodes.push_back(v);
-            }
-          }
-          path.clear();
-
-          // Global update heuristic
-          if (relabel_cnt >= next_global_update_limit) {
-            globalUpdate();
-            next_global_update_limit += global_update_skip;
-          }
-        }
-
-      }
-
-    }
-
-    /// Execute the algorithm performing push and relabel operations
-    void startPush() {
-      // Paramters for heuristics
-      const int PRICE_REFINEMENT_LIMIT = 2;
-      const double GLOBAL_UPDATE_FACTOR = 2.0;
-
-      const int global_update_skip = static_cast<int>(GLOBAL_UPDATE_FACTOR *
-        (_res_node_num + _sup_node_num * _sup_node_num));
-      int next_global_update_limit = global_update_skip;
-
-      // Perform cost scaling phases
-      BoolVector hyper(_res_node_num, false);
-      LargeCostVector hyper_cost(_res_node_num);
-      int relabel_cnt = 0;
-      int eps_phase_cnt = 0;
-      for ( ; _epsilon >= 1; _epsilon = _epsilon < _alpha && _epsilon > 1 ?
-                                        1 : _epsilon / _alpha )
-      {
-        ++eps_phase_cnt;
-
-        // Price refinement heuristic
-        if (eps_phase_cnt >= PRICE_REFINEMENT_LIMIT) {
-          if (priceRefinement()) continue;
-        }
-
-        // Initialize current phase
-        initPhase();
-
-        // Perform push and relabel operations
-        while (_active_nodes.size() > 0) {
-          LargeCost min_red_cost, rc, pi_n;
-          Value delta;
-          int n, t, a, last_out = _res_arc_num;
-
-        next_node:
-          // Select an active node (FIFO selection)
-          n = _active_nodes.front();
-          last_out = _first_out[n+1];
-          pi_n = _pi[n];
-
-          // Perform push operations if there are admissible arcs
-          if (_excess[n] > 0) {
-            for (a = _next_out[n]; a != last_out; ++a) {
-              if (_res_cap[a] > 0 &&
-                  _cost[a] + pi_n - _pi[_target[a]] < 0) {
-                delta = std::min(_res_cap[a], _excess[n]);
-                t = _target[a];
-
-                // Push-look-ahead heuristic
-                Value ahead = -_excess[t];
-                int last_out_t = _first_out[t+1];
-                LargeCost pi_t = _pi[t];
-                for (int ta = _next_out[t]; ta != last_out_t; ++ta) {
-                  if (_res_cap[ta] > 0 &&
-                      _cost[ta] + pi_t - _pi[_target[ta]] < 0)
-                    ahead += _res_cap[ta];
-                  if (ahead >= delta) break;
-                }
-                if (ahead < 0) ahead = 0;
-
-                // Push flow along the arc
-                if (ahead < delta && !hyper[t]) {
-                  _res_cap[a] -= ahead;
-                  _res_cap[_reverse[a]] += ahead;
-                  _excess[n] -= ahead;
-                  _excess[t] += ahead;
-                  _active_nodes.push_front(t);
-                  hyper[t] = true;
-                  hyper_cost[t] = _cost[a] + pi_n - pi_t;
-                  _next_out[n] = a;
-                  goto next_node;
-                } else {
-                  _res_cap[a] -= delta;
-                  _res_cap[_reverse[a]] += delta;
-                  _excess[n] -= delta;
-                  _excess[t] += delta;
-                  if (_excess[t] > 0 && _excess[t] <= delta)
-                    _active_nodes.push_back(t);
-                }
-
-                if (_excess[n] == 0) {
-                  _next_out[n] = a;
-                  goto remove_nodes;
-                }
-              }
-            }
-            _next_out[n] = a;
-          }
-
-          // Relabel the node if it is still active (or hyper)
-          if (_excess[n] > 0 || hyper[n]) {
-             min_red_cost = hyper[n] ? -hyper_cost[n] :
-               std::numeric_limits<LargeCost>::max();
-            for (int a = _first_out[n]; a != last_out; ++a) {
-              if (_res_cap[a] > 0) {
-                rc = _cost[a] + pi_n - _pi[_target[a]];
-                if (rc < min_red_cost) {
-                  min_red_cost = rc;
-                }
-              }
-            }
-            _pi[n] -= min_red_cost + _epsilon;
-            _next_out[n] = _first_out[n];
-            hyper[n] = false;
-            ++relabel_cnt;
-          }
-
-          // Remove nodes that are not active nor hyper
-        remove_nodes:
-          while ( _active_nodes.size() > 0 &&
-                  _excess[_active_nodes.front()] <= 0 &&
-                  !hyper[_active_nodes.front()] ) {
-            _active_nodes.pop_front();
-          }
-
-          // Global update heuristic
-          if (relabel_cnt >= next_global_update_limit) {
-            globalUpdate();
-            for (int u = 0; u != _res_node_num; ++u)
-              hyper[u] = false;
-            next_global_update_limit += global_update_skip;
-          }
-        }
-      }
-    }
-
-  }; //class CostScaling
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_COST_SCALING_H
Index: lemon/counter.h
===================================================================
--- lemon/counter.h	(revision 786)
+++ lemon/counter.h	(revision 440)
@@ -213,5 +213,5 @@
   /// 'Do nothing' version of Counter.
 
-  /// This class can be used in the same way as \ref Counter, but it
+  /// This class can be used in the same way as \ref Counter however it
   /// does not count at all and does not print report on destruction.
   ///
Index: lemon/cplex.cc
===================================================================
--- lemon/cplex.cc	(revision 989)
+++ lemon/cplex.cc	(revision 988)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -112,37 +112,4 @@
   }
 
-  int CplexBase::_addRow(Value lb, ExprIterator b,
-                         ExprIterator e, Value ub) {
-    int i = CPXgetnumrows(cplexEnv(), _prob);
-    if (lb == -INF) {
-      const char s = 'L';
-      CPXnewrows(cplexEnv(), _prob, 1, &ub, &s, 0, 0);
-    } else if (ub == INF) {
-      const char s = 'G';
-      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
-    } else if (lb == ub){
-      const char s = 'E';
-      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, 0, 0);
-    } else {
-      const char s = 'R';
-      double len = ub - lb;
-      CPXnewrows(cplexEnv(), _prob, 1, &lb, &s, &len, 0);
-    }
-
-    std::vector<int> indices;
-    std::vector<int> rowlist;
-    std::vector<Value> values;
-
-    for(ExprIterator it=b; it!=e; ++it) {
-      indices.push_back(it->first);
-      values.push_back(it->second);
-      rowlist.push_back(i);
-    }
-
-    CPXchgcoeflist(cplexEnv(), _prob, values.size(),
-                   &rowlist.front(), &indices.front(), &values.front());
-
-    return i;
-  }
 
   void CplexBase::_eraseCol(int i) {
@@ -488,5 +455,5 @@
 
   void CplexBase::_applyMessageLevel() {
-    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND,
+    CPXsetintparam(cplexEnv(), CPX_PARAM_SCRIND, 
                    _message_enabled ? CPX_ON : CPX_OFF);
   }
Index: lemon/cplex.h
===================================================================
--- lemon/cplex.h	(revision 746)
+++ lemon/cplex.h	(revision 576)
@@ -94,5 +94,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
Index: mon/cycle_canceling.h
===================================================================
--- lemon/cycle_canceling.h	(revision 922)
+++ 	(revision )
@@ -1,1170 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_CYCLE_CANCELING_H
-#define LEMON_CYCLE_CANCELING_H
-
-/// \ingroup min_cost_flow_algs
-/// \file
-/// \brief Cycle-canceling algorithms for finding a minimum cost flow.
-
-#include <vector>
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/maps.h>
-#include <lemon/path.h>
-#include <lemon/math.h>
-#include <lemon/static_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/circulation.h>
-#include <lemon/bellman_ford.h>
-#include <lemon/howard_mmc.h>
-
-namespace lemon {
-
-  /// \addtogroup min_cost_flow_algs
-  /// @{
-
-  /// \brief Implementation of cycle-canceling algorithms for
-  /// finding a \ref min_cost_flow "minimum cost flow".
-  ///
-  /// \ref CycleCanceling implements three different cycle-canceling
-  /// algorithms for finding a \ref min_cost_flow "minimum cost flow"
-  /// \ref amo93networkflows, \ref klein67primal,
-  /// \ref goldberg89cyclecanceling.
-  /// The most efficent one (both theoretically and practically)
-  /// is the \ref CANCEL_AND_TIGHTEN "Cancel and Tighten" algorithm,
-  /// thus it is the default method.
-  /// It is strongly polynomial, but in practice, it is typically much
-  /// slower than the scaling algorithms and NetworkSimplex.
-  ///
-  /// Most of the parameters of the problem (except for the digraph)
-  /// can be given using separate functions, and the algorithm can be
-  /// executed using the \ref run() function. If some parameters are not
-  /// specified, then default values will be used.
-  ///
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
-  ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
-  /// be integer.
-  /// \warning This algorithm does not support negative costs for
-  /// arcs having infinite upper bound.
-  ///
-  /// \note For more information about the three available methods,
-  /// see \ref Method.
-#ifdef DOXYGEN
-  template <typename GR, typename V, typename C>
-#else
-  template <typename GR, typename V = int, typename C = V>
-#endif
-  class CycleCanceling
-  {
-  public:
-
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the flow amounts, capacity bounds and supply values
-    typedef V Value;
-    /// The type of the arc costs
-    typedef C Cost;
-
-  public:
-
-    /// \brief Problem type constants for the \c run() function.
-    ///
-    /// Enum type containing the problem type constants that can be
-    /// returned by the \ref run() function of the algorithm.
-    enum ProblemType {
-      /// The problem has no feasible solution (flow).
-      INFEASIBLE,
-      /// The problem has optimal solution (i.e. it is feasible and
-      /// bounded), and the algorithm has found optimal flow and node
-      /// potentials (primal and dual solutions).
-      OPTIMAL,
-      /// The digraph contains an arc of negative cost and infinite
-      /// upper bound. It means that the objective function is unbounded
-      /// on that arc, however, note that it could actually be bounded
-      /// over the feasible flows, but this algroithm cannot handle
-      /// these cases.
-      UNBOUNDED
-    };
-
-    /// \brief Constants for selecting the used method.
-    ///
-    /// Enum type containing constants for selecting the used method
-    /// for the \ref run() function.
-    ///
-    /// \ref CycleCanceling provides three different cycle-canceling
-    /// methods. By default, \ref CANCEL_AND_TIGHTEN "Cancel and Tighten"
-    /// is used, which is by far the most efficient and the most robust.
-    /// However, the other methods can be selected using the \ref run()
-    /// function with the proper parameter.
-    enum Method {
-      /// A simple cycle-canceling method, which uses the
-      /// \ref BellmanFord "Bellman-Ford" algorithm with limited iteration
-      /// number for detecting negative cycles in the residual network.
-      SIMPLE_CYCLE_CANCELING,
-      /// The "Minimum Mean Cycle-Canceling" algorithm, which is a
-      /// well-known strongly polynomial method
-      /// \ref goldberg89cyclecanceling. It improves along a
-      /// \ref min_mean_cycle "minimum mean cycle" in each iteration.
-      /// Its running time complexity is O(n<sup>2</sup>m<sup>3</sup>log(n)).
-      MINIMUM_MEAN_CYCLE_CANCELING,
-      /// The "Cancel And Tighten" algorithm, which can be viewed as an
-      /// improved version of the previous method
-      /// \ref goldberg89cyclecanceling.
-      /// It is faster both in theory and in practice, its running time
-      /// complexity is O(n<sup>2</sup>m<sup>2</sup>log(n)).
-      CANCEL_AND_TIGHTEN
-    };
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<double> DoubleVector;
-    typedef std::vector<Value> ValueVector;
-    typedef std::vector<Cost> CostVector;
-    typedef std::vector<char> BoolVector;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-  private:
-
-    template <typename KT, typename VT>
-    class StaticVectorMap {
-    public:
-      typedef KT Key;
-      typedef VT Value;
-
-      StaticVectorMap(std::vector<Value>& v) : _v(v) {}
-
-      const Value& operator[](const Key& key) const {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      Value& operator[](const Key& key) {
-        return _v[StaticDigraph::id(key)];
-      }
-
-      void set(const Key& key, const Value& val) {
-        _v[StaticDigraph::id(key)] = val;
-      }
-
-    private:
-      std::vector<Value>& _v;
-    };
-
-    typedef StaticVectorMap<StaticDigraph::Node, Cost> CostNodeMap;
-    typedef StaticVectorMap<StaticDigraph::Arc, Cost> CostArcMap;
-
-  private:
-
-
-    // Data related to the underlying digraph
-    const GR &_graph;
-    int _node_num;
-    int _arc_num;
-    int _res_node_num;
-    int _res_arc_num;
-    int _root;
-
-    // Parameters of the problem
-    bool _have_lower;
-    Value _sum_supply;
-
-    // Data structures for storing the digraph
-    IntNodeMap _node_id;
-    IntArcMap _arc_idf;
-    IntArcMap _arc_idb;
-    IntVector _first_out;
-    BoolVector _forward;
-    IntVector _source;
-    IntVector _target;
-    IntVector _reverse;
-
-    // Node and arc data
-    ValueVector _lower;
-    ValueVector _upper;
-    CostVector _cost;
-    ValueVector _supply;
-
-    ValueVector _res_cap;
-    CostVector _pi;
-
-    // Data for a StaticDigraph structure
-    typedef std::pair<int, int> IntPair;
-    StaticDigraph _sgr;
-    std::vector<IntPair> _arc_vec;
-    std::vector<Cost> _cost_vec;
-    IntVector _id_vec;
-    CostArcMap _cost_map;
-    CostNodeMap _pi_map;
-
-  public:
-
-    /// \brief Constant for infinite upper bounds (capacities).
-    ///
-    /// Constant for infinite upper bounds (capacities).
-    /// It is \c std::numeric_limits<Value>::infinity() if available,
-    /// \c std::numeric_limits<Value>::max() otherwise.
-    const Value INF;
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param graph The digraph the algorithm runs on.
-    CycleCanceling(const GR& graph) :
-      _graph(graph), _node_id(graph), _arc_idf(graph), _arc_idb(graph),
-      _cost_map(_cost_vec), _pi_map(_pi),
-      INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() :
-          std::numeric_limits<Value>::max())
-    {
-      // Check the number types
-      LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
-        "The flow type of CycleCanceling must be signed");
-      LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
-        "The cost type of CycleCanceling must be signed");
-
-      // Reset data structures
-      reset();
-    }
-
-    /// \name Parameters
-    /// The parameters of the algorithm can be specified using these
-    /// functions.
-
-    /// @{
-
-    /// \brief Set the lower bounds on the arcs.
-    ///
-    /// This function sets the lower bounds on the arcs.
-    /// If it is not used before calling \ref run(), the lower bounds
-    /// will be set to zero on all arcs.
-    ///
-    /// \param map An arc map storing the lower bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template <typename LowerMap>
-    CycleCanceling& lowerMap(const LowerMap& map) {
-      _have_lower = true;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _lower[_arc_idf[a]] = map[a];
-        _lower[_arc_idb[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the upper bounds (capacities) on the arcs.
-    ///
-    /// This function sets the upper bounds (capacities) on the arcs.
-    /// If it is not used before calling \ref run(), the upper bounds
-    /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
-    ///
-    /// \param map An arc map storing the upper bounds.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename UpperMap>
-    CycleCanceling& upperMap(const UpperMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _upper[_arc_idf[a]] = map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the costs of the arcs.
-    ///
-    /// This function sets the costs of the arcs.
-    /// If it is not used before calling \ref run(), the costs
-    /// will be set to \c 1 on all arcs.
-    ///
-    /// \param map An arc map storing the costs.
-    /// Its \c Value type must be convertible to the \c Cost type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename CostMap>
-    CycleCanceling& costMap(const CostMap& map) {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        _cost[_arc_idf[a]] =  map[a];
-        _cost[_arc_idb[a]] = -map[a];
-      }
-      return *this;
-    }
-
-    /// \brief Set the supply values of the nodes.
-    ///
-    /// This function sets the supply values of the nodes.
-    /// If neither this function nor \ref stSupply() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// \param map A node map storing the supply values.
-    /// Its \c Value type must be convertible to the \c Value type
-    /// of the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    template<typename SupplyMap>
-    CycleCanceling& supplyMap(const SupplyMap& map) {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _supply[_node_id[n]] = map[n];
-      }
-      return *this;
-    }
-
-    /// \brief Set single source and target nodes and a supply value.
-    ///
-    /// This function sets a single source node and a single target node
-    /// and the required flow value.
-    /// If neither this function nor \ref supplyMap() is used before
-    /// calling \ref run(), the supply of each node will be set to zero.
-    ///
-    /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
-    /// assigned to \c t and all other nodes have zero supply value.
-    ///
-    /// \param s The source node.
-    /// \param t The target node.
-    /// \param k The required amount of flow from node \c s to node \c t
-    /// (i.e. the supply of \c s and the demand of \c t).
-    ///
-    /// \return <tt>(*this)</tt>
-    CycleCanceling& stSupply(const Node& s, const Node& t, Value k) {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      _supply[_node_id[s]] =  k;
-      _supply[_node_id[t]] = -k;
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Execution control
-    /// The algorithm can be executed using \ref run().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    /// For example,
-    /// \code
-    ///   CycleCanceling<ListDigraph> cc(graph);
-    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
-    ///
-    /// \param method The cycle-canceling method that will be used.
-    /// For more information, see \ref Method.
-    ///
-    /// \return \c INFEASIBLE if no feasible flow exists,
-    /// \n \c OPTIMAL if the problem has optimal solution
-    /// (i.e. it is feasible and bounded), and the algorithm has found
-    /// optimal flow and node potentials (primal and dual solutions),
-    /// \n \c UNBOUNDED if the digraph contains an arc of negative cost
-    /// and infinite upper bound. It means that the objective function
-    /// is unbounded on that arc, however, note that it could actually be
-    /// bounded over the feasible flows, but this algroithm cannot handle
-    /// these cases.
-    ///
-    /// \see ProblemType, Method
-    /// \see resetParams(), reset()
-    ProblemType run(Method method = CANCEL_AND_TIGHTEN) {
-      ProblemType pt = init();
-      if (pt != OPTIMAL) return pt;
-      start(method);
-      return OPTIMAL;
-    }
-
-    /// \brief Reset all the parameters that have been given before.
-    ///
-    /// This function resets all the paramaters that have been given
-    /// before using functions \ref lowerMap(), \ref upperMap(),
-    /// \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// For example,
-    /// \code
-    ///   CycleCanceling<ListDigraph> cs(graph);
-    ///
-    ///   // First run
-    ///   cc.lowerMap(lower).upperMap(upper).costMap(cost)
-    ///     .supplyMap(sup).run();
-    ///
-    ///   // Run again with modified cost map (resetParams() is not called,
-    ///   // so only the cost map have to be set again)
-    ///   cost[e] += 100;
-    ///   cc.costMap(cost).run();
-    ///
-    ///   // Run again from scratch using resetParams()
-    ///   // (the lower bounds will be set to zero on all arcs)
-    ///   cc.resetParams();
-    ///   cc.upperMap(capacity).costMap(cost)
-    ///     .supplyMap(sup).run();
-    /// \endcode
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    CycleCanceling& resetParams() {
-      for (int i = 0; i != _res_node_num; ++i) {
-        _supply[i] = 0;
-      }
-      int limit = _first_out[_root];
-      for (int j = 0; j != limit; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _cost[j] = _forward[j] ? 1 : -1;
-      }
-      for (int j = limit; j != _res_arc_num; ++j) {
-        _lower[j] = 0;
-        _upper[j] = INF;
-        _cost[j] = 0;
-        _cost[_reverse[j]] = 0;
-      }
-      _have_lower = false;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    CycleCanceling& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      _res_node_num = _node_num + 1;
-      _res_arc_num = 2 * (_arc_num + _node_num);
-      _root = _node_num;
-
-      _first_out.resize(_res_node_num + 1);
-      _forward.resize(_res_arc_num);
-      _source.resize(_res_arc_num);
-      _target.resize(_res_arc_num);
-      _reverse.resize(_res_arc_num);
-
-      _lower.resize(_res_arc_num);
-      _upper.resize(_res_arc_num);
-      _cost.resize(_res_arc_num);
-      _supply.resize(_res_node_num);
-
-      _res_cap.resize(_res_arc_num);
-      _pi.resize(_res_node_num);
-
-      _arc_vec.reserve(_res_arc_num);
-      _cost_vec.reserve(_res_arc_num);
-      _id_vec.reserve(_res_arc_num);
-
-      // Copy the graph
-      int i = 0, j = 0, k = 2 * _arc_num + _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _first_out[i] = j;
-        for (OutArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idf[a] = j;
-          _forward[j] = true;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        for (InArcIt a(_graph, n); a != INVALID; ++a, ++j) {
-          _arc_idb[a] = j;
-          _forward[j] = false;
-          _source[j] = i;
-          _target[j] = _node_id[_graph.runningNode(a)];
-        }
-        _forward[j] = false;
-        _source[j] = i;
-        _target[j] = _root;
-        _reverse[j] = k;
-        _forward[k] = true;
-        _source[k] = _root;
-        _target[k] = i;
-        _reverse[k] = j;
-        ++j; ++k;
-      }
-      _first_out[i] = j;
-      _first_out[_res_node_num] = k;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int fi = _arc_idf[a];
-        int bi = _arc_idb[a];
-        _reverse[fi] = bi;
-        _reverse[bi] = fi;
-      }
-
-      // Reset parameters
-      resetParams();
-      return *this;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The \ref run() function must be called before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found flow.
-    ///
-    /// This function returns the total cost of the found flow.
-    /// Its complexity is O(e).
-    ///
-    /// \note The return type of the function can be specified as a
-    /// template parameter. For example,
-    /// \code
-    ///   cc.totalCost<double>();
-    /// \endcode
-    /// It is useful if the total cost cannot be stored in the \c Cost
-    /// type of the algorithm, which is the default return type of the
-    /// function.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename Number>
-    Number totalCost() const {
-      Number c = 0;
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        int i = _arc_idb[a];
-        c += static_cast<Number>(_res_cap[i]) *
-             (-static_cast<Number>(_cost[i]));
-      }
-      return c;
-    }
-
-#ifndef DOXYGEN
-    Cost totalCost() const {
-      return totalCost<Cost>();
-    }
-#endif
-
-    /// \brief Return the flow on the given arc.
-    ///
-    /// This function returns the flow on the given arc.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Value flow(const Arc& a) const {
-      return _res_cap[_arc_idb[a]];
-    }
-
-    /// \brief Return the flow map (the primal solution).
-    ///
-    /// This function copies the flow value on each arc into the given
-    /// map. The \c Value type of the algorithm must be convertible to
-    /// the \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename FlowMap>
-    void flowMap(FlowMap &map) const {
-      for (ArcIt a(_graph); a != INVALID; ++a) {
-        map.set(a, _res_cap[_arc_idb[a]]);
-      }
-    }
-
-    /// \brief Return the potential (dual value) of the given node.
-    ///
-    /// This function returns the potential (dual value) of the
-    /// given node.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    Cost potential(const Node& n) const {
-      return static_cast<Cost>(_pi[_node_id[n]]);
-    }
-
-    /// \brief Return the potential map (the dual solution).
-    ///
-    /// This function copies the potential (dual value) of each node
-    /// into the given map.
-    /// The \c Cost type of the algorithm must be convertible to the
-    /// \c Value type of the map.
-    ///
-    /// \pre \ref run() must be called before using this function.
-    template <typename PotentialMap>
-    void potentialMap(PotentialMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map.set(n, static_cast<Cost>(_pi[_node_id[n]]));
-      }
-    }
-
-    /// @}
-
-  private:
-
-    // Initialize the algorithm
-    ProblemType init() {
-      if (_res_node_num <= 1) return INFEASIBLE;
-
-      // Check the sum of supply values
-      _sum_supply = 0;
-      for (int i = 0; i != _root; ++i) {
-        _sum_supply += _supply[i];
-      }
-      if (_sum_supply > 0) return INFEASIBLE;
-
-
-      // Initialize vectors
-      for (int i = 0; i != _res_node_num; ++i) {
-        _pi[i] = 0;
-      }
-      ValueVector excess(_supply);
-
-      // Remove infinite upper bounds and check negative arcs
-      const Value MAX = std::numeric_limits<Value>::max();
-      int last_out;
-      if (_have_lower) {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j]) {
-              Value c = _cost[j] < 0 ? _upper[j] : _lower[j];
-              if (c >= MAX) return UNBOUNDED;
-              excess[i] -= c;
-              excess[_target[j]] += c;
-            }
-          }
-        }
-      } else {
-        for (int i = 0; i != _root; ++i) {
-          last_out = _first_out[i+1];
-          for (int j = _first_out[i]; j != last_out; ++j) {
-            if (_forward[j] && _cost[j] < 0) {
-              Value c = _upper[j];
-              if (c >= MAX) return UNBOUNDED;
-              excess[i] -= c;
-              excess[_target[j]] += c;
-            }
-          }
-        }
-      }
-      Value ex, max_cap = 0;
-      for (int i = 0; i != _res_node_num; ++i) {
-        ex = excess[i];
-        if (ex < 0) max_cap -= ex;
-      }
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_upper[j] >= MAX) _upper[j] = max_cap;
-      }
-
-      // Initialize maps for Circulation and remove non-zero lower bounds
-      ConstMap<Arc, Value> low(0);
-      typedef typename Digraph::template ArcMap<Value> ValueArcMap;
-      typedef typename Digraph::template NodeMap<Value> ValueNodeMap;
-      ValueArcMap cap(_graph), flow(_graph);
-      ValueNodeMap sup(_graph);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sup[n] = _supply[_node_id[n]];
-      }
-      if (_have_lower) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          int j = _arc_idf[a];
-          Value c = _lower[j];
-          cap[a] = _upper[j] - c;
-          sup[_graph.source(a)] -= c;
-          sup[_graph.target(a)] += c;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          cap[a] = _upper[_arc_idf[a]];
-        }
-      }
-
-      // Find a feasible flow using Circulation
-      Circulation<Digraph, ConstMap<Arc, Value>, ValueArcMap, ValueNodeMap>
-        circ(_graph, low, cap, sup);
-      if (!circ.flowMap(flow).run()) return INFEASIBLE;
-
-      // Set residual capacities and handle GEQ supply type
-      if (_sum_supply < 0) {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-          sup[_graph.source(a)] -= fa;
-          sup[_graph.target(a)] += fa;
-        }
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          excess[_node_id[n]] = sup[n];
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int u = _target[a];
-          int ra = _reverse[a];
-          _res_cap[a] = -_sum_supply + 1;
-          _res_cap[ra] = -excess[u];
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      } else {
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          Value fa = flow[a];
-          _res_cap[_arc_idf[a]] = cap[a] - fa;
-          _res_cap[_arc_idb[a]] = fa;
-        }
-        for (int a = _first_out[_root]; a != _res_arc_num; ++a) {
-          int ra = _reverse[a];
-          _res_cap[a] = 1;
-          _res_cap[ra] = 0;
-          _cost[a] = 0;
-          _cost[ra] = 0;
-        }
-      }
-
-      return OPTIMAL;
-    }
-
-    // Build a StaticDigraph structure containing the current
-    // residual network
-    void buildResidualNetwork() {
-      _arc_vec.clear();
-      _cost_vec.clear();
-      _id_vec.clear();
-      for (int j = 0; j != _res_arc_num; ++j) {
-        if (_res_cap[j] > 0) {
-          _arc_vec.push_back(IntPair(_source[j], _target[j]));
-          _cost_vec.push_back(_cost[j]);
-          _id_vec.push_back(j);
-        }
-      }
-      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
-    }
-
-    // Execute the algorithm and transform the results
-    void start(Method method) {
-      // Execute the algorithm
-      switch (method) {
-        case SIMPLE_CYCLE_CANCELING:
-          startSimpleCycleCanceling();
-          break;
-        case MINIMUM_MEAN_CYCLE_CANCELING:
-          startMinMeanCycleCanceling();
-          break;
-        case CANCEL_AND_TIGHTEN:
-          startCancelAndTighten();
-          break;
-      }
-
-      // Compute node potentials
-      if (method != SIMPLE_CYCLE_CANCELING) {
-        buildResidualNetwork();
-        typename BellmanFord<StaticDigraph, CostArcMap>
-          ::template SetDistMap<CostNodeMap>::Create bf(_sgr, _cost_map);
-        bf.distMap(_pi_map);
-        bf.init(0);
-        bf.start();
-      }
-
-      // Handle non-zero lower bounds
-      if (_have_lower) {
-        int limit = _first_out[_root];
-        for (int j = 0; j != limit; ++j) {
-          if (!_forward[j]) _res_cap[j] += _lower[j];
-        }
-      }
-    }
-
-    // Execute the "Simple Cycle Canceling" method
-    void startSimpleCycleCanceling() {
-      // Constants for computing the iteration limits
-      const int BF_FIRST_LIMIT  = 2;
-      const double BF_LIMIT_FACTOR = 1.5;
-
-      typedef StaticVectorMap<StaticDigraph::Arc, Value> FilterMap;
-      typedef FilterArcs<StaticDigraph, FilterMap> ResDigraph;
-      typedef StaticVectorMap<StaticDigraph::Node, StaticDigraph::Arc> PredMap;
-      typedef typename BellmanFord<ResDigraph, CostArcMap>
-        ::template SetDistMap<CostNodeMap>
-        ::template SetPredMap<PredMap>::Create BF;
-
-      // Build the residual network
-      _arc_vec.clear();
-      _cost_vec.clear();
-      for (int j = 0; j != _res_arc_num; ++j) {
-        _arc_vec.push_back(IntPair(_source[j], _target[j]));
-        _cost_vec.push_back(_cost[j]);
-      }
-      _sgr.build(_res_node_num, _arc_vec.begin(), _arc_vec.end());
-
-      FilterMap filter_map(_res_cap);
-      ResDigraph rgr(_sgr, filter_map);
-      std::vector<int> cycle;
-      std::vector<StaticDigraph::Arc> pred(_res_arc_num);
-      PredMap pred_map(pred);
-      BF bf(rgr, _cost_map);
-      bf.distMap(_pi_map).predMap(pred_map);
-
-      int length_bound = BF_FIRST_LIMIT;
-      bool optimal = false;
-      while (!optimal) {
-        bf.init(0);
-        int iter_num = 0;
-        bool cycle_found = false;
-        while (!cycle_found) {
-          // Perform some iterations of the Bellman-Ford algorithm
-          int curr_iter_num = iter_num + length_bound <= _node_num ?
-            length_bound : _node_num - iter_num;
-          iter_num += curr_iter_num;
-          int real_iter_num = curr_iter_num;
-          for (int i = 0; i < curr_iter_num; ++i) {
-            if (bf.processNextWeakRound()) {
-              real_iter_num = i;
-              break;
-            }
-          }
-          if (real_iter_num < curr_iter_num) {
-            // Optimal flow is found
-            optimal = true;
-            break;
-          } else {
-            // Search for node disjoint negative cycles
-            std::vector<int> state(_res_node_num, 0);
-            int id = 0;
-            for (int u = 0; u != _res_node_num; ++u) {
-              if (state[u] != 0) continue;
-              ++id;
-              int v = u;
-              for (; v != -1 && state[v] == 0; v = pred[v] == INVALID ?
-                   -1 : rgr.id(rgr.source(pred[v]))) {
-                state[v] = id;
-              }
-              if (v != -1 && state[v] == id) {
-                // A negative cycle is found
-                cycle_found = true;
-                cycle.clear();
-                StaticDigraph::Arc a = pred[v];
-                Value d, delta = _res_cap[rgr.id(a)];
-                cycle.push_back(rgr.id(a));
-                while (rgr.id(rgr.source(a)) != v) {
-                  a = pred_map[rgr.source(a)];
-                  d = _res_cap[rgr.id(a)];
-                  if (d < delta) delta = d;
-                  cycle.push_back(rgr.id(a));
-                }
-
-                // Augment along the cycle
-                for (int i = 0; i < int(cycle.size()); ++i) {
-                  int j = cycle[i];
-                  _res_cap[j] -= delta;
-                  _res_cap[_reverse[j]] += delta;
-                }
-              }
-            }
-          }
-
-          // Increase iteration limit if no cycle is found
-          if (!cycle_found) {
-            length_bound = static_cast<int>(length_bound * BF_LIMIT_FACTOR);
-          }
-        }
-      }
-    }
-
-    // Execute the "Minimum Mean Cycle Canceling" method
-    void startMinMeanCycleCanceling() {
-      typedef SimplePath<StaticDigraph> SPath;
-      typedef typename SPath::ArcIt SPathArcIt;
-      typedef typename HowardMmc<StaticDigraph, CostArcMap>
-        ::template SetPath<SPath>::Create MMC;
-
-      SPath cycle;
-      MMC mmc(_sgr, _cost_map);
-      mmc.cycle(cycle);
-      buildResidualNetwork();
-      while (mmc.findCycleMean() && mmc.cycleCost() < 0) {
-        // Find the cycle
-        mmc.findCycle();
-
-        // Compute delta value
-        Value delta = INF;
-        for (SPathArcIt a(cycle); a != INVALID; ++a) {
-          Value d = _res_cap[_id_vec[_sgr.id(a)]];
-          if (d < delta) delta = d;
-        }
-
-        // Augment along the cycle
-        for (SPathArcIt a(cycle); a != INVALID; ++a) {
-          int j = _id_vec[_sgr.id(a)];
-          _res_cap[j] -= delta;
-          _res_cap[_reverse[j]] += delta;
-        }
-
-        // Rebuild the residual network
-        buildResidualNetwork();
-      }
-    }
-
-    // Execute the "Cancel And Tighten" method
-    void startCancelAndTighten() {
-      // Constants for the min mean cycle computations
-      const double LIMIT_FACTOR = 1.0;
-      const int MIN_LIMIT = 5;
-
-      // Contruct auxiliary data vectors
-      DoubleVector pi(_res_node_num, 0.0);
-      IntVector level(_res_node_num);
-      BoolVector reached(_res_node_num);
-      BoolVector processed(_res_node_num);
-      IntVector pred_node(_res_node_num);
-      IntVector pred_arc(_res_node_num);
-      std::vector<int> stack(_res_node_num);
-      std::vector<int> proc_vector(_res_node_num);
-
-      // Initialize epsilon
-      double epsilon = 0;
-      for (int a = 0; a != _res_arc_num; ++a) {
-        if (_res_cap[a] > 0 && -_cost[a] > epsilon)
-          epsilon = -_cost[a];
-      }
-
-      // Start phases
-      Tolerance<double> tol;
-      tol.epsilon(1e-6);
-      int limit = int(LIMIT_FACTOR * std::sqrt(double(_res_node_num)));
-      if (limit < MIN_LIMIT) limit = MIN_LIMIT;
-      int iter = limit;
-      while (epsilon * _res_node_num >= 1) {
-        // Find and cancel cycles in the admissible network using DFS
-        for (int u = 0; u != _res_node_num; ++u) {
-          reached[u] = false;
-          processed[u] = false;
-        }
-        int stack_head = -1;
-        int proc_head = -1;
-        for (int start = 0; start != _res_node_num; ++start) {
-          if (reached[start]) continue;
-
-          // New start node
-          reached[start] = true;
-          pred_arc[start] = -1;
-          pred_node[start] = -1;
-
-          // Find the first admissible outgoing arc
-          double p = pi[start];
-          int a = _first_out[start];
-          int last_out = _first_out[start+1];
-          for (; a != last_out && (_res_cap[a] == 0 ||
-               !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-          if (a == last_out) {
-            processed[start] = true;
-            proc_vector[++proc_head] = start;
-            continue;
-          }
-          stack[++stack_head] = a;
-
-          while (stack_head >= 0) {
-            int sa = stack[stack_head];
-            int u = _source[sa];
-            int v = _target[sa];
-
-            if (!reached[v]) {
-              // A new node is reached
-              reached[v] = true;
-              pred_node[v] = u;
-              pred_arc[v] = sa;
-              p = pi[v];
-              a = _first_out[v];
-              last_out = _first_out[v+1];
-              for (; a != last_out && (_res_cap[a] == 0 ||
-                   !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-              stack[++stack_head] = a == last_out ? -1 : a;
-            } else {
-              if (!processed[v]) {
-                // A cycle is found
-                int n, w = u;
-                Value d, delta = _res_cap[sa];
-                for (n = u; n != v; n = pred_node[n]) {
-                  d = _res_cap[pred_arc[n]];
-                  if (d <= delta) {
-                    delta = d;
-                    w = pred_node[n];
-                  }
-                }
-
-                // Augment along the cycle
-                _res_cap[sa] -= delta;
-                _res_cap[_reverse[sa]] += delta;
-                for (n = u; n != v; n = pred_node[n]) {
-                  int pa = pred_arc[n];
-                  _res_cap[pa] -= delta;
-                  _res_cap[_reverse[pa]] += delta;
-                }
-                for (n = u; stack_head > 0 && n != w; n = pred_node[n]) {
-                  --stack_head;
-                  reached[n] = false;
-                }
-                u = w;
-              }
-              v = u;
-
-              // Find the next admissible outgoing arc
-              p = pi[v];
-              a = stack[stack_head] + 1;
-              last_out = _first_out[v+1];
-              for (; a != last_out && (_res_cap[a] == 0 ||
-                   !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-              stack[stack_head] = a == last_out ? -1 : a;
-            }
-
-            while (stack_head >= 0 && stack[stack_head] == -1) {
-              processed[v] = true;
-              proc_vector[++proc_head] = v;
-              if (--stack_head >= 0) {
-                // Find the next admissible outgoing arc
-                v = _source[stack[stack_head]];
-                p = pi[v];
-                a = stack[stack_head] + 1;
-                last_out = _first_out[v+1];
-                for (; a != last_out && (_res_cap[a] == 0 ||
-                     !tol.negative(_cost[a] + p - pi[_target[a]])); ++a) ;
-                stack[stack_head] = a == last_out ? -1 : a;
-              }
-            }
-          }
-        }
-
-        // Tighten potentials and epsilon
-        if (--iter > 0) {
-          for (int u = 0; u != _res_node_num; ++u) {
-            level[u] = 0;
-          }
-          for (int i = proc_head; i > 0; --i) {
-            int u = proc_vector[i];
-            double p = pi[u];
-            int l = level[u] + 1;
-            int last_out = _first_out[u+1];
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              int v = _target[a];
-              if (_res_cap[a] > 0 && tol.negative(_cost[a] + p - pi[v]) &&
-                  l > level[v]) level[v] = l;
-            }
-          }
-
-          // Modify potentials
-          double q = std::numeric_limits<double>::max();
-          for (int u = 0; u != _res_node_num; ++u) {
-            int lu = level[u];
-            double p, pu = pi[u];
-            int last_out = _first_out[u+1];
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              if (_res_cap[a] == 0) continue;
-              int v = _target[a];
-              int ld = lu - level[v];
-              if (ld > 0) {
-                p = (_cost[a] + pu - pi[v] + epsilon) / (ld + 1);
-                if (p < q) q = p;
-              }
-            }
-          }
-          for (int u = 0; u != _res_node_num; ++u) {
-            pi[u] -= q * level[u];
-          }
-
-          // Modify epsilon
-          epsilon = 0;
-          for (int u = 0; u != _res_node_num; ++u) {
-            double curr, pu = pi[u];
-            int last_out = _first_out[u+1];
-            for (int a = _first_out[u]; a != last_out; ++a) {
-              if (_res_cap[a] == 0) continue;
-              curr = _cost[a] + pu - pi[_target[a]];
-              if (-curr > epsilon) epsilon = -curr;
-            }
-          }
-        } else {
-          typedef HowardMmc<StaticDigraph, CostArcMap> MMC;
-          typedef typename BellmanFord<StaticDigraph, CostArcMap>
-            ::template SetDistMap<CostNodeMap>::Create BF;
-
-          // Set epsilon to the minimum cycle mean
-          buildResidualNetwork();
-          MMC mmc(_sgr, _cost_map);
-          mmc.findCycleMean();
-          epsilon = -mmc.cycleMean();
-          Cost cycle_cost = mmc.cycleCost();
-          int cycle_size = mmc.cycleSize();
-
-          // Compute feasible potentials for the current epsilon
-          for (int i = 0; i != int(_cost_vec.size()); ++i) {
-            _cost_vec[i] = cycle_size * _cost_vec[i] - cycle_cost;
-          }
-          BF bf(_sgr, _cost_map);
-          bf.distMap(_pi_map);
-          bf.init(0);
-          bf.start();
-          for (int u = 0; u != _res_node_num; ++u) {
-            pi[u] = static_cast<double>(_pi[u]) / cycle_size;
-          }
-
-          iter = limit;
-        }
-      }
-    }
-
-  }; //class CycleCanceling
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_CYCLE_CANCELING_H
Index: lemon/dfs.h
===================================================================
--- lemon/dfs.h	(revision 976)
+++ lemon/dfs.h	(revision 975)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -48,5 +48,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -63,6 +63,5 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -83,6 +82,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a \c ReachedMap.
@@ -99,5 +97,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a \c DistMap.
@@ -123,9 +121,4 @@
   ///\tparam GR The type of the digraph the algorithm runs on.
   ///The default type is \ref ListDigraph.
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref DfsDefaultTraits
-  ///"DfsDefaultTraits<GR>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR,
@@ -232,5 +225,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap : public Dfs<Digraph, SetPredMapTraits<T> > {
@@ -252,5 +245,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap : public Dfs< Digraph, SetDistMapTraits<T> > {
@@ -272,6 +265,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ReachedMap type.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     template <class T>
     struct SetReachedMap : public Dfs< Digraph, SetReachedMapTraits<T> > {
@@ -293,5 +285,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap : public Dfs< Digraph, SetProcessedMapTraits<T> > {
@@ -420,6 +412,6 @@
     ///The simplest way to execute the DFS algorithm is to use one of the
     ///member functions called \ref run(Node) "run()".\n
-    ///If you need better control on the execution, you have to call
-    ///\ref init() first, then you can add a source node with \ref addSource()
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), then you can add a source node with \ref addSource()
     ///and perform the actual computation with \ref start().
     ///This procedure can be repeated if there are nodes that have not
@@ -641,6 +633,10 @@
     ///Runs the algorithm to visit all nodes in the digraph.
 
-    ///This method runs the %DFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs the %DFS algorithm in order to compute the
+    ///%DFS path to each node.
+    ///
+    ///The algorithm computes
+    ///- the %DFS tree (forest),
+    ///- the distance of each node from the root(s) in the %DFS tree.
     ///
     ///\note <tt>d.run()</tt> is just a shortcut of the following code.
@@ -674,7 +670,7 @@
     ///@{
 
-    ///The DFS path to the given node.
-
-    ///Returns the DFS path to the given node from the root(s).
+    ///The DFS path to a node.
+
+    ///Returns the DFS path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -684,7 +680,7 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -695,5 +691,5 @@
     int dist(Node v) const { return (*_dist)[v]; }
 
-    ///Returns the 'previous arc' of the %DFS tree for the given node.
+    ///Returns the 'previous arc' of the %DFS tree for a node.
 
     ///This function returns the 'previous arc' of the %DFS tree for the
@@ -703,5 +699,5 @@
     ///
     ///The %DFS tree used here is equal to the %DFS tree used in
-    ///\ref predNode() and \ref predMap().
+    ///\ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -709,13 +705,13 @@
     Arc predArc(Node v) const { return (*_pred)[v];}
 
-    ///Returns the 'previous node' of the %DFS tree for the given node.
+    ///Returns the 'previous node' of the %DFS tree.
 
     ///This function returns the 'previous node' of the %DFS
     ///tree for the node \c v, i.e. it returns the last but one node
-    ///of a %DFS path from a root to \c v. It is \c INVALID
+    ///from a %DFS path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The %DFS tree used here is equal to the %DFS tree used in
-    ///\ref predArc() and \ref predMap().
+    ///\ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -738,5 +734,5 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the DFS tree (forest).
+    ///arcs, which form the DFS tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -744,5 +740,5 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node. node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -770,5 +766,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the %DFS paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -785,6 +781,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
@@ -805,6 +801,5 @@
 
     ///The type of the map that indicates which nodes are reached.
-    ///It must conform to
-    ///the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    ///It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
     ///Instantiates a ReachedMap.
@@ -821,5 +816,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<int> DistMap;
     ///Instantiates a DistMap.
@@ -836,5 +831,5 @@
 
     ///The type of the DFS paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -842,6 +837,10 @@
   /// Default traits class used by DfsWizard
 
-  /// Default traits class used by DfsWizard.
-  /// \tparam GR The type of the digraph.
+  /// To make it easier to use Dfs algorithm
+  /// we have created a wizard class.
+  /// This \ref DfsWizard class needs default traits,
+  /// as well as the \ref Dfs class.
+  /// The \ref DfsWizardBase is a class to be the default traits of the
+  /// \ref DfsWizard class.
   template<class GR>
   class DfsWizardBase : public DfsWizardDefaultTraits<GR>
@@ -871,5 +870,5 @@
     /// Constructor.
 
-    /// This constructor does not require parameters, it initiates
+    /// This constructor does not require parameters, therefore it initiates
     /// all of the attributes to \c 0.
     DfsWizardBase() : _g(0), _reached(0), _processed(0), _pred(0),
@@ -896,7 +895,4 @@
   /// This class should only be used through the \ref dfs() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class DfsWizard : public TR
@@ -904,4 +900,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -911,8 +908,14 @@
     typedef typename Digraph::OutArcIt OutArcIt;
 
+    ///\brief The type of the map that stores the predecessor
+    ///arcs of the DFS paths.
     typedef typename TR::PredMap PredMap;
+    ///\brief The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
+    ///\brief The type of the map that indicates which nodes are reached.
     typedef typename TR::ReachedMap ReachedMap;
+    ///\brief The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
+    ///The type of the DFS paths
     typedef typename TR::Path Path;
 
@@ -984,6 +987,6 @@
     ///Runs DFS algorithm to visit all nodes in the digraph.
 
-    ///This method runs DFS algorithm in order to visit all nodes
-    ///in the digraph.
+    ///This method runs DFS algorithm in order to compute
+    ///the DFS path to each node.
     void run()
     {
@@ -997,10 +1000,9 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the predecessor map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the predecessor arcs of the nodes.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     DfsWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1016,10 +1018,9 @@
       SetReachedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the reached map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are reached.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ReachedMap object.
     template<class T>
     DfsWizard<SetReachedMapBase<T> > reachedMap(const T &t)
@@ -1035,11 +1036,9 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the distance map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the distances of the nodes calculated
-    ///by the algorithm.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     DfsWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1055,10 +1054,9 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-func-param "Named parameter" for setting
-    ///the processed map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are processed.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     DfsWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1212,6 +1210,5 @@
     ///
     /// The type of the map that indicates which nodes are reached.
-    /// It must conform to the
-    /// \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
     typedef typename Digraph::template NodeMap<bool> ReachedMap;
 
@@ -1251,9 +1248,9 @@
   /// does not observe the DFS events. If you want to observe the DFS
   /// events, you should implement your own visitor class.
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref DfsVisitDefaultTraits
-  /// "DfsVisitDefaultTraits<GR>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
+  /// \tparam TR Traits class to set various data types used by the
+  /// algorithm. The default traits class is
+  /// \ref DfsVisitDefaultTraits "DfsVisitDefaultTraits<GR>".
+  /// See \ref DfsVisitDefaultTraits for the documentation of
+  /// a DFS visit traits class.
 #ifdef DOXYGEN
   template <typename GR, typename VS, typename TR>
@@ -1374,6 +1371,6 @@
     /// The simplest way to execute the DFS algorithm is to use one of the
     /// member functions called \ref run(Node) "run()".\n
-    /// If you need better control on the execution, you have to call
-    /// \ref init() first, then you can add a source node with \ref addSource()
+    /// If you need more control on the execution, first you have to call
+    /// \ref init(), then you can add a source node with \ref addSource()
     /// and perform the actual computation with \ref start().
     /// This procedure can be repeated if there are nodes that have not
@@ -1588,6 +1585,10 @@
     /// \brief Runs the algorithm to visit all nodes in the digraph.
 
-    /// This method runs the %DFS algorithm in order to visit all nodes
-    /// in the digraph.
+    /// This method runs the %DFS algorithm in order to
+    /// compute the %DFS path to each node.
+    ///
+    /// The algorithm computes
+    /// - the %DFS tree (forest),
+    /// - the distance of each node from the root(s) in the %DFS tree.
     ///
     /// \note <tt>d.run()</tt> is just a shortcut of the following code.
@@ -1621,5 +1622,5 @@
     ///@{
 
-    /// \brief Checks if the given node is reached from the root(s).
+    /// \brief Checks if a node is reached from the root(s).
     ///
     /// Returns \c true if \c v is reached from the root(s).
Index: mon/dheap.h
===================================================================
--- lemon/dheap.h	(revision 855)
+++ 	(revision )
@@ -1,352 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_DHEAP_H
-#define LEMON_DHEAP_H
-
-///\ingroup heaps
-///\file
-///\brief D-ary heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief D-ary heap data structure.
-  ///
-  /// This class implements the \e D-ary \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The \ref DHeap "D-ary heap" is a generalization of the
-  /// \ref BinHeap "binary heap" structure, its nodes have at most
-  /// \c D children, instead of two.
-  /// \ref BinHeap and \ref QuadHeap are specialized implementations
-  /// of this structure for <tt>D=2</tt> and <tt>D=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 D The degree of the heap, each node have at most \e D
-  /// children. The default is 16. Powers of two are suggested to use
-  /// so that the multiplications and divisions needed to traverse the
-  /// nodes of the heap could be performed faster.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-  ///
-  ///\sa BinHeap
-  ///\sa FouraryHeap
-#ifdef DOXYGEN
-  template <typename PR, typename IM, int D, typename CMP>
-#else
-  template <typename PR, typename IM, int D = 16,
-            typename CMP = std::less<PR> >
-#endif
-  class DHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit DHeap(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.
-    DHeap(ItemIntMap &map, const Compare &comp)
-      : _iim(map), _comp(comp) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() { _data.clear(); }
-
-  private:
-    int parent(int i) { return (i-1)/D; }
-    int firstChild(int i) { return D*i+1; }
-
-    bool less(const Pair &p1, const Pair &p2) const {
-      return _comp(p1.second, p2.second);
-    }
-
-    void bubbleUp(int hole, Pair p) {
-      int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
-        hole = par;
-        par = parent(hole);
-      }
-      move(p, hole);
-    }
-
-    void bubbleDown(int hole, Pair p, int length) {
-      if( length>1 ) {
-        int child = firstChild(hole);
-        while( child+D<=length ) {
-          int min=child;
-          for (int i=1; i<D; ++i) {
-            if( less(_data[child+i], _data[min]) )
-              min=child+i;
-          }
-          if( !less(_data[min], p) )
-            goto ok;
-          move(_data[min], hole);
-          hole = min;
-          child = firstChild(hole);
-        }
-        if ( child<length ) {
-          int min = child;
-          while (++child < length) {
-            if( less(_data[child], _data[min]) )
-              min=child;
-          }
-          if( less(_data[min], p) ) {
-            move(_data[min], hole);
-            hole = min;
-          }
-        }
-      }
-    ok:
-      move(p, hole);
-    }
-
-    void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
-    }
-
-  public:
-    /// \brief Insert a pair of item and priority into the heap.
-    ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
-    /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
-    void push(const Pair &p) {
-      int n = _data.size();
-      _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param i The item to insert.
-    /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[0].first; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[0].second; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
-      if (n>0) bubbleDown(0, _data[n], n);
-      _data.pop_back();
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
-    void erase(const Item &i) {
-      int h = _iim[i];
-      int n = _data.size()-1;
-      _iim.set(_data[h].first, POST_HEAP);
-      if( h<n ) {
-        if( less(_data[parent(h)], _data[n]) )
-          bubbleDown(h, _data[n], n);
-        else
-          bubbleUp(h, _data[n]);
-      }
-      _data.pop_back();
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].second;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param i The item.
-    /// \param p The priority.
-    void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      if( idx<0 )
-        push(i,p);
-      else if( _comp(p, _data[idx].second) )
-        bubbleUp(idx, Pair(i,p));
-      else
-        bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
-    void increase(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int s = _iim[i];
-      if (s>=0) s=0;
-      return State(s);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-        case POST_HEAP:
-        case PRE_HEAP:
-          if (state(i) == IN_HEAP) erase(i);
-          _iim[i] = st;
-          break;
-        case IN_HEAP:
-          break;
-      }
-    }
-
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
-    void replace(const Item& i, const Item& j) {
-      int idx=_iim[i];
-      _iim.set(i, _iim[j]);
-      _iim.set(j, idx);
-      _data[idx].first=j;
-    }
-
-  }; // class DHeap
-
-} // namespace lemon
-
-#endif // LEMON_DHEAP_H
Index: lemon/dijkstra.h
===================================================================
--- lemon/dijkstra.h	(revision 877)
+++ lemon/dijkstra.h	(revision 584)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -71,7 +71,7 @@
 
     ///The type of the map that stores the arc lengths.
-    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
-    ///The type of the arc lengths.
+    ///The type of the length of the arcs.
     typedef typename LEN::Value Value;
 
@@ -117,5 +117,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a \c PredMap.
@@ -132,6 +132,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a \c ProcessedMap.
@@ -152,5 +152,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a \c DistMap.
@@ -169,8 +169,4 @@
   /// \ingroup shortest_path
   ///This class provides an efficient implementation of the %Dijkstra algorithm.
-  ///
-  ///The %Dijkstra algorithm solves the single-source shortest path problem
-  ///when all arc lengths are non-negative. If there are negative lengths,
-  ///the BellmanFord algorithm should be used instead.
   ///
   ///The arc lengths are passed to the algorithm using a
@@ -193,9 +189,4 @@
   ///it is necessary. The default map type is \ref
   ///concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  ///\tparam TR The traits class that defines various types used by the
-  ///algorithm. By default, it is \ref DijkstraDefaultTraits
-  ///"DijkstraDefaultTraits<GR, LEN>".
-  ///In most cases, this parameter should not be set directly,
-  ///consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename LEN, typename TR>
@@ -211,6 +202,6 @@
     typedef typename TR::Digraph Digraph;
 
-    ///The type of the arc lengths.
-    typedef typename TR::Value Value;
+    ///The type of the length of the arcs.
+    typedef typename TR::LengthMap::Value Value;
     ///The type of the map that stores the arc lengths.
     typedef typename TR::LengthMap LengthMap;
@@ -314,5 +305,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c PredMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetPredMap
@@ -335,5 +326,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c DistMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetDistMap
@@ -356,5 +347,5 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c ProcessedMap type.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     template <class T>
     struct SetProcessedMap
@@ -432,5 +423,5 @@
     ///passed to the constructor of the cross reference and the cross
     ///reference should be passed to the constructor of the heap).
-    ///However, external heap and cross reference objects could also be
+    ///However external heap and cross reference objects could also be
     ///passed to the algorithm using the \ref heap() function before
     ///calling \ref run(Node) "run()" or \ref init().
@@ -453,5 +444,4 @@
     ///\ref named-templ-param "Named parameter" for setting
     ///\c OperationTraits type.
-    /// For more information, see \ref DijkstraDefaultOperationTraits.
     template <class T>
     struct SetOperationTraits
@@ -595,6 +585,6 @@
     ///The simplest way to execute the %Dijkstra algorithm is to use
     ///one of the member functions called \ref run(Node) "run()".\n
-    ///If you need better control on the execution, you have to call
-    ///\ref init() first, then you can add several source nodes with
+    ///If you need more control on the execution, first you have to call
+    ///\ref init(), then you can add several source nodes with
     ///\ref addSource(). Finally the actual path computation can be
     ///performed with one of the \ref start() functions.
@@ -812,12 +802,12 @@
     ///The results of the %Dijkstra algorithm can be obtained using these
     ///functions.\n
-    ///Either \ref run(Node) "run()" or \ref init() should be called
+    ///Either \ref run(Node) "run()" or \ref start() should be called
     ///before using them.
 
     ///@{
 
-    ///The shortest path to the given node.
-
-    ///Returns the shortest path to the given node from the root(s).
+    ///The shortest path to a node.
+
+    ///Returns the shortest path to a node.
     ///
     ///\warning \c t should be reached from the root(s).
@@ -827,7 +817,7 @@
     Path path(Node t) const { return Path(*G, *_pred, t); }
 
-    ///The distance of the given node from the root(s).
-
-    ///Returns the distance of the given node from the root(s).
+    ///The distance of a node from the root(s).
+
+    ///Returns the distance of a node from the root(s).
     ///
     ///\warning If node \c v is not reached from the root(s), then
@@ -838,7 +828,6 @@
     Value dist(Node v) const { return (*_dist)[v]; }
 
-    ///\brief Returns the 'previous arc' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous arc' of the shortest path tree for a node.
+
     ///This function returns the 'previous arc' of the shortest path
     ///tree for the node \c v, i.e. it returns the last arc of a
@@ -847,5 +836,5 @@
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predNode() and \ref predMap().
+    ///tree used in \ref predNode().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -853,14 +842,13 @@
     Arc predArc(Node v) const { return (*_pred)[v]; }
 
-    ///\brief Returns the 'previous node' of the shortest path tree for
-    ///the given node.
-    ///
+    ///Returns the 'previous node' of the shortest path tree for a node.
+
     ///This function returns the 'previous node' of the shortest path
     ///tree for the node \c v, i.e. it returns the last but one node
-    ///of a shortest path from a root to \c v. It is \c INVALID
+    ///from a shortest path from a root to \c v. It is \c INVALID
     ///if \c v is not reached from the root(s) or if \c v is a root.
     ///
     ///The shortest path tree used here is equal to the shortest path
-    ///tree used in \ref predArc() and \ref predMap().
+    ///tree used in \ref predArc().
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -883,5 +871,5 @@
     ///
     ///Returns a const reference to the node map that stores the predecessor
-    ///arcs, which form the shortest path tree (forest).
+    ///arcs, which form the shortest path tree.
     ///
     ///\pre Either \ref run(Node) "run()" or \ref init()
@@ -889,5 +877,5 @@
     const PredMap &predMap() const { return *_pred;}
 
-    ///Checks if the given node is reached from the root(s).
+    ///Checks if a node is reached from the root(s).
 
     ///Returns \c true if \c v is reached from the root(s).
@@ -908,7 +896,7 @@
                                           Heap::POST_HEAP; }
 
-    ///The current distance of the given node from the root(s).
-
-    ///Returns the current distance of the given node from the root(s).
+    ///The current distance of a node from the root(s).
+
+    ///Returns the current distance of a node from the root(s).
     ///It may be decreased in the following processes.
     ///
@@ -937,7 +925,7 @@
 
     ///The type of the map that stores the arc lengths.
-    ///It must conform to the \ref concepts::ReadMap "ReadMap" concept.
+    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
     typedef LEN LengthMap;
-    ///The type of the arc lengths.
+    ///The type of the length of the arcs.
     typedef typename LEN::Value Value;
 
@@ -986,5 +974,5 @@
     ///The type of the map that stores the predecessor
     ///arcs of the shortest paths.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename Digraph::Arc> PredMap;
     ///Instantiates a PredMap.
@@ -1001,6 +989,6 @@
 
     ///The type of the map that indicates which nodes are processed.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///By default, it is a NullMap.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
+    ///By default it is a NullMap.
     typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
     ///Instantiates a ProcessedMap.
@@ -1021,5 +1009,5 @@
 
     ///The type of the map that stores the distances of the nodes.
-    ///It must conform to the \ref concepts::WriteMap "WriteMap" concept.
+    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
     typedef typename Digraph::template NodeMap<typename LEN::Value> DistMap;
     ///Instantiates a DistMap.
@@ -1036,5 +1024,5 @@
 
     ///The type of the shortest paths.
-    ///It must conform to the \ref concepts::Path "Path" concept.
+    ///It must meet the \ref concepts::Path "Path" concept.
     typedef lemon::Path<Digraph> Path;
   };
@@ -1042,7 +1030,10 @@
   /// Default traits class used by DijkstraWizard
 
-  /// Default traits class used by DijkstraWizard.
-  /// \tparam GR The type of the digraph.
-  /// \tparam LEN The type of the length map.
+  /// To make it easier to use Dijkstra algorithm
+  /// we have created a wizard class.
+  /// This \ref DijkstraWizard class needs default traits,
+  /// as well as the \ref Dijkstra class.
+  /// The \ref DijkstraWizardBase is a class to be the default traits of the
+  /// \ref DijkstraWizard class.
   template<typename GR, typename LEN>
   class DijkstraWizardBase : public DijkstraWizardDefaultTraits<GR,LEN>
@@ -1098,7 +1089,4 @@
   /// This class should only be used through the \ref dijkstra() function,
   /// which makes it easier to use the algorithm.
-  ///
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm.
   template<class TR>
   class DijkstraWizard : public TR
@@ -1106,4 +1094,5 @@
     typedef TR Base;
 
+    ///The type of the digraph the algorithm runs on.
     typedef typename TR::Digraph Digraph;
 
@@ -1113,10 +1102,18 @@
     typedef typename Digraph::OutArcIt OutArcIt;
 
+    ///The type of the map that stores the arc lengths.
     typedef typename TR::LengthMap LengthMap;
+    ///The type of the length of the arcs.
     typedef typename LengthMap::Value Value;
+    ///\brief The type of the map that stores the predecessor
+    ///arcs of the shortest paths.
     typedef typename TR::PredMap PredMap;
+    ///The type of the map that stores the distances of the nodes.
     typedef typename TR::DistMap DistMap;
+    ///The type of the map that indicates which nodes are processed.
     typedef typename TR::ProcessedMap ProcessedMap;
+    ///The type of the shortest paths
     typedef typename TR::Path Path;
+    ///The heap type used by the dijkstra algorithm.
     typedef typename TR::Heap Heap;
 
@@ -1190,10 +1187,9 @@
       SetPredMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the predecessor map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the predecessor arcs of the nodes.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting PredMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting PredMap object.
     template<class T>
     DijkstraWizard<SetPredMapBase<T> > predMap(const T &t)
@@ -1209,11 +1205,9 @@
       SetDistMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-templ-param "Named parameter" for setting
-    ///the distance map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that stores the distances of the nodes calculated
-    ///by the algorithm.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting DistMap object.
+    ///
+    ///\ref named-func-param "Named parameter"
+    ///for setting DistMap object.
     template<class T>
     DijkstraWizard<SetDistMapBase<T> > distMap(const T &t)
@@ -1229,10 +1223,9 @@
       SetProcessedMapBase(const TR &b) : TR(b) {}
     };
-
-    ///\brief \ref named-func-param "Named parameter" for setting
-    ///the processed map.
-    ///
-    ///\ref named-templ-param "Named parameter" function for setting
-    ///the map that indicates which nodes are processed.
+    ///\brief \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
+    ///
+    /// \ref named-func-param "Named parameter"
+    ///for setting ProcessedMap object.
     template<class T>
     DijkstraWizard<SetProcessedMapBase<T> > processedMap(const T &t)
@@ -1247,5 +1240,4 @@
       SetPathBase(const TR &b) : TR(b) {}
     };
-
     ///\brief \ref named-func-param "Named parameter"
     ///for getting the shortest path to the target node.
Index: lemon/dim2.h
===================================================================
--- lemon/dim2.h	(revision 714)
+++ lemon/dim2.h	(revision 440)
@@ -22,7 +22,14 @@
 #include <iostream>
 
-///\ingroup geomdat
+///\ingroup misc
 ///\file
 ///\brief A simple two dimensional vector and a bounding box implementation
+///
+/// The class \ref lemon::dim2::Point "dim2::Point" implements
+/// a two dimensional vector with the usual operations.
+///
+/// The class \ref lemon::dim2::Box "dim2::Box" can be used to determine
+/// the rectangular bounding box of a set of
+/// \ref lemon::dim2::Point "dim2::Point"'s.
 
 namespace lemon {
@@ -34,5 +41,5 @@
   namespace dim2 {
 
-  /// \addtogroup geomdat
+  /// \addtogroup misc
   /// @{
 
Index: lemon/dimacs.h
===================================================================
--- lemon/dimacs.h	(revision 877)
+++ lemon/dimacs.h	(revision 584)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -62,5 +62,5 @@
 
   ///This function starts seeking the beginning of the given file for the
-  ///problem type and size info.
+  ///problem type and size info. 
   ///The found data is returned in a special struct that can be evaluated
   ///and passed to the appropriate reader function.
@@ -213,5 +213,5 @@
         std::numeric_limits<Capacity>::infinity() :
         std::numeric_limits<Capacity>::max();
-
+ 
     while (is >> c) {
       switch (c) {
@@ -238,5 +238,5 @@
           e = g.addArc(nodes[i], nodes[j]);
           capacity.set(e, _cap);
-        }
+        } 
         else if (desc.type==DimacsDescriptor::MAX) {
           is >> i >> j >> _cap;
@@ -363,9 +363,9 @@
     g.addArc(s,t);
   }
-
+  
   /// \brief DIMACS plain (di)graph reader function.
   ///
   /// This function reads a plain (di)graph without any designated nodes
-  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from
+  /// and maps (e.g. a matching instance) from DIMACS format, i.e. from 
   /// DIMACS files having a line starting with
   /// \code
@@ -393,5 +393,5 @@
       nodes[k] = g.addNode();
     }
-
+    
     while (is >> c) {
       switch (c) {
Index: lemon/edge_set.h
===================================================================
--- lemon/edge_set.h	(revision 877)
+++ lemon/edge_set.h	(revision 670)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -256,12 +256,11 @@
   /// all arcs incident to the given node is erased from the arc set.
   ///
-  /// This class fully conforms to the \ref concepts::Digraph
-  /// "Digraph" concept.
-  /// It provides only linear time counting for nodes and arcs.
-  ///
   /// \param GR The type of the graph which shares its node set with
   /// this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
   /// concept.
+  ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph" concept.
   template <typename GR>
   class ListArcSet : public ArcSetExtender<ListArcSetBase<GR> > {
@@ -687,11 +686,10 @@
   /// incident to the given node is erased from the arc set.
   ///
-  /// This class fully conforms to the \ref concepts::Graph "Graph"
-  /// concept.
-  /// It provides only linear time counting for nodes, edges and arcs.
-  ///
   /// \param GR The type of the graph which shares its node set
   /// with this class. Its interface must conform to the
   /// \ref concepts::Digraph "Digraph" or \ref concepts::Graph "Graph"
+  /// concept.
+  ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph"
   /// concept.
   template <typename GR>
@@ -870,5 +868,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc.id;
     }
@@ -957,12 +955,11 @@
   /// arcs. Therefore the arcs cannot be erased from the arc sets.
   ///
-  /// This class fully conforms to the \ref concepts::Digraph "Digraph"
-  /// concept.
-  /// It provides only linear time counting for nodes and arcs.
-  ///
   /// \warning If a node is erased from the underlying graph and this
   /// node is the source or target of one arc in the arc set, then
   /// the arc set is invalidated, and it cannot be used anymore. The
   /// validity can be checked with the \c valid() member function.
+  ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph" concept.
   template <typename GR>
   class SmartArcSet : public ArcSetExtender<SmartArcSetBase<GR> > {
@@ -1177,5 +1174,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc.id;
     }
@@ -1185,5 +1182,5 @@
     }
 
-    static void next(Edge& arc) {
+    void next(Edge& arc) const {
       --arc.id;
     }
@@ -1308,12 +1305,11 @@
   /// edges cannot be erased from the edge sets.
   ///
-  /// This class fully conforms to the \ref concepts::Graph "Graph"
-  /// concept.
-  /// It provides only linear time counting for nodes, edges and arcs.
-  ///
   /// \warning If a node is erased from the underlying graph and this
   /// node is incident to one edge in the edge set, then the edge set
   /// is invalidated, and it cannot be used anymore. The validity can
   /// be checked with the \c valid() member function.
+  ///
+  /// This class fully conforms to the \ref concepts::Graph
+  /// "Graph" concept.
   template <typename GR>
   class SmartEdgeSet : public EdgeSetExtender<SmartEdgeSetBase<GR> > {
Index: lemon/euler.h
===================================================================
--- lemon/euler.h	(revision 919)
+++ lemon/euler.h	(revision 648)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -27,5 +27,5 @@
 /// \ingroup graph_properties
 /// \file
-/// \brief Euler tour iterators and a function for checking the \e Eulerian
+/// \brief Euler tour iterators and a function for checking the \e Eulerian 
 /// property.
 ///
@@ -37,10 +37,10 @@
   ///Euler tour iterator for digraphs.
 
-  /// \ingroup graph_properties
+  /// \ingroup graph_prop
   ///This iterator provides an Euler tour (Eulerian circuit) of a \e directed
   ///graph (if there exists) and it converts to the \c Arc type of the digraph.
   ///
   ///For example, if the given digraph has an Euler tour (i.e it has only one
-  ///non-trivial component and the in-degree is equal to the out-degree
+  ///non-trivial component and the in-degree is equal to the out-degree 
   ///for all nodes), then the following code will put the arcs of \c g
   ///to the vector \c et according to an Euler tour of \c g.
@@ -139,5 +139,5 @@
   ///and \c Edge types of the graph.
   ///
-  ///For example, if the given graph has an Euler tour (i.e it has only one
+  ///For example, if the given graph has an Euler tour (i.e it has only one 
   ///non-trivial component and the degree of each node is even),
   ///the following code will print the arc IDs according to an
@@ -148,5 +148,5 @@
   ///  }
   ///\endcode
-  ///Although this iterator is for undirected graphs, it still returns
+  ///Although this iterator is for undirected graphs, it still returns 
   ///arcs in order to indicate the direction of the tour.
   ///(But arcs convert to edges, of course.)
@@ -234,5 +234,5 @@
     /// Postfix incrementation.
     ///
-    ///\warning This incrementation returns an \c Arc (which converts to
+    ///\warning This incrementation returns an \c Arc (which converts to 
     ///an \c Edge), not an \ref EulerIt, as one may expect.
     Arc operator++(int)
Index: lemon/fib_heap.h
===================================================================
--- lemon/fib_heap.h	(revision 711)
+++ lemon/fib_heap.h	(revision 683)
@@ -21,9 +21,8 @@
 
 ///\file
-///\ingroup heaps
-///\brief Fibonacci heap implementation.
+///\ingroup auxdat
+///\brief Fibonacci Heap implementation.
 
 #include <vector>
-#include <utility>
 #include <functional>
 #include <lemon/math.h>
@@ -31,37 +30,42 @@
 namespace lemon {
 
-  /// \ingroup heaps
+  /// \ingroup auxdat
   ///
-  /// \brief Fibonacci heap data structure.
+  ///\brief Fibonacci Heap.
   ///
-  /// This class implements the \e Fibonacci \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
+  ///This class implements the \e Fibonacci \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 CMP specifies the ordering of the priorities. In a heap
+  ///one can change the priority of an item, add or erase an item, etc.
   ///
-  /// The methods \ref increase() and \ref erase() are not efficient in a
-  /// Fibonacci heap. In case of many calls of these operations, it is
-  /// better to use other heap structure, e.g. \ref BinHeap "binary heap".
+  ///The methods \ref increase and \ref erase are not efficient in a Fibonacci
+  ///heap. In case of many calls to these operations, it is better to use a
+  ///\ref BinHeap "binary heap".
   ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
+  ///\param PRIO Type of the priority of the items.
+  ///\param IM A read and writable Item int map, used internally
+  ///to handle the cross references.
+  ///\param CMP A class for the ordering of the priorities. The
+  ///default is \c std::less<PRIO>.
+  ///
+  ///\sa BinHeap
+  ///\sa Dijkstra
 #ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
+  template <typename PRIO, typename IM, typename CMP>
 #else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
+  template <typename PRIO, typename IM, typename CMP = std::less<PRIO> >
 #endif
   class FibHeap {
   public:
-
-    /// Type of the item-int map.
+    ///\e
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
+    ///\e
+    typedef PRIO Prio;
+    ///\e
     typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
+    ///\e
     typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
+    ///\e
     typedef CMP Compare;
 
@@ -77,8 +81,8 @@
   public:
 
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
@@ -91,20 +95,16 @@
     };
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
+    /// \brief The constructor
+    ///
+    /// \c map should be given to the constructor, since it is
+    ///   used internally to handle the cross references.
     explicit FibHeap(ItemIntMap &map)
       : _minimum(0), _iim(map), _num() {}
 
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
+    /// \brief The constructor
+    ///
+    /// \c map 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.
     FibHeap(ItemIntMap &map, const Compare &comp)
       : _minimum(0), _iim(map), _comp(comp), _num() {}
@@ -112,31 +112,41 @@
     /// \brief The number of items stored in the heap.
     ///
-    /// This function returns the number of items stored in the heap.
+    /// Returns the number of items stored in the heap.
     int size() const { return _num; }
 
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
+    /// \brief Checks if the heap stores no items.
+    ///
+    ///   Returns \c true if and only if the heap stores no items.
     bool empty() const { return _num==0; }
 
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
+    /// \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.
     void clear() {
       _data.clear(); _minimum = 0; _num = 0;
     }
 
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param item The item to insert.
-    /// \param prio The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& prio) {
+    /// \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.
+    void set (const Item& item, const Prio& value) {
+      int i=_iim[item];
+      if ( i >= 0 && _data[i].in ) {
+        if ( _comp(value, _data[i].prio) ) decrease(item, value);
+        if ( _comp(_data[i].prio, value) ) increase(item, value);
+      } else push(item, value);
+    }
+
+    /// \brief 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.
+    void push (const Item& item, const Prio& value) {
       int i=_iim[item];
       if ( i < 0 ) {
@@ -159,28 +169,38 @@
         _data[_minimum].right_neighbor=i;
         _data[i].left_neighbor=_minimum;
-        if ( _comp( prio, _data[_minimum].prio) ) _minimum=i;
+        if ( _comp( value, _data[_minimum].prio) ) _minimum=i;
       } else {
         _data[i].right_neighbor=_data[i].left_neighbor=i;
         _minimum=i;
       }
-      _data[i].prio=prio;
+      _data[i].prio=value;
       ++_num;
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority relative to \c Compare.
+    ///
+    /// This method returns the item with minimum priority relative to \c
+    /// Compare.
+    /// \pre The heap must be nonempty.
     Item top() const { return _data[_minimum].name; }
 
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[_minimum].prio; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \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 _data[_minimum].prio; }
+
+    /// \brief Returns the priority of \c item.
+    ///
+    /// It returns the priority of \c item.
+    /// \pre \c item must be in the heap.
+    const Prio& operator[](const Item& item) const {
+      return _data[_iim[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.
     /// \pre The heap must be non-empty.
     void pop() {
@@ -189,5 +209,5 @@
         _data[_minimum].in=false;
         if ( _data[_minimum].degree!=0 ) {
-          makeRoot(_data[_minimum].child);
+          makeroot(_data[_minimum].child);
           _minimum=_data[_minimum].child;
           balance();
@@ -202,5 +222,5 @@
           int last_child=_data[child].left_neighbor;
 
-          makeRoot(child);
+          makeroot(child);
 
           _data[left].right_neighbor=child;
@@ -215,10 +235,8 @@
     }
 
-    /// \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.
+    /// \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 Fibonacci heaps.
     void erase (const Item& item) {
       int i=_iim[item];
@@ -235,66 +253,41 @@
     }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    Prio operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param item The item.
-    /// \param prio The priority.
-    void set (const Item& item, const Prio& prio) {
+    /// \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.
+    void decrease (Item item, const Prio& value) {
       int i=_iim[item];
-      if ( i >= 0 && _data[i].in ) {
-        if ( _comp(prio, _data[i].prio) ) decrease(item, prio);
-        if ( _comp(_data[i].prio, prio) ) increase(item, prio);
-      } else push(item, prio);
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param prio The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e prio.
-    void decrease (const Item& item, const Prio& prio) {
-      int i=_iim[item];
-      _data[i].prio=prio;
+      _data[i].prio=value;
       int p=_data[i].parent;
 
-      if ( p!=-1 && _comp(prio, _data[p].prio) ) {
+      if ( p!=-1 && _comp(value, _data[p].prio) ) {
         cut(i,p);
         cascade(p);
       }
-      if ( _comp(prio, _data[_minimum].prio) ) _minimum=i;
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param prio The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e prio.
-    void increase (const Item& item, const Prio& prio) {
+      if ( _comp(value, _data[_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.
+    void increase (Item item, const Prio& value) {
       erase(item);
-      push(item, prio);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param item The item.
+      push(item, value);
+    }
+
+
+    /// \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.
     State state(const Item &item) const {
       int i=_iim[item];
@@ -306,9 +299,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time _complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
@@ -373,5 +366,5 @@
     }
 
-    void makeRoot(int c) {
+    void makeroot(int c) {
       int s=c;
       do {
Index: mon/fractional_matching.h
===================================================================
--- lemon/fractional_matching.h	(revision 877)
+++ 	(revision )
@@ -1,2139 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_FRACTIONAL_MATCHING_H
-#define LEMON_FRACTIONAL_MATCHING_H
-
-#include <vector>
-#include <queue>
-#include <set>
-#include <limits>
-
-#include <lemon/core.h>
-#include <lemon/unionfind.h>
-#include <lemon/bin_heap.h>
-#include <lemon/maps.h>
-#include <lemon/assert.h>
-#include <lemon/elevator.h>
-
-///\ingroup matching
-///\file
-///\brief Fractional matching algorithms in general graphs.
-
-namespace lemon {
-
-  /// \brief Default traits class of MaxFractionalMatching class.
-  ///
-  /// Default traits class of MaxFractionalMatching class.
-  /// \tparam GR Graph type.
-  template <typename GR>
-  struct MaxFractionalMatchingDefaultTraits {
-
-    /// \brief The type of the graph the algorithm runs on.
-    typedef GR Graph;
-
-    /// \brief The type of the map that stores the matching.
-    ///
-    /// The type of the map that stores the matching arcs.
-    /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-    typedef typename Graph::template NodeMap<typename GR::Arc> MatchingMap;
-
-    /// \brief Instantiates a MatchingMap.
-    ///
-    /// This function instantiates a \ref MatchingMap.
-    /// \param graph The graph for which we would like to define
-    /// the matching map.
-    static MatchingMap* createMatchingMap(const Graph& graph) {
-      return new MatchingMap(graph);
-    }
-
-    /// \brief The elevator type used by MaxFractionalMatching algorithm.
-    ///
-    /// The elevator type used by MaxFractionalMatching algorithm.
-    ///
-    /// \sa Elevator
-    /// \sa LinkedElevator
-    typedef LinkedElevator<Graph, typename Graph::Node> Elevator;
-
-    /// \brief Instantiates an Elevator.
-    ///
-    /// This function instantiates an \ref Elevator.
-    /// \param graph The graph for which we would like to define
-    /// the elevator.
-    /// \param max_level The maximum level of the elevator.
-    static Elevator* createElevator(const Graph& graph, int max_level) {
-      return new Elevator(graph, max_level);
-    }
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Max cardinality fractional matching
-  ///
-  /// This class provides an implementation of fractional matching
-  /// algorithm based on push-relabel principle.
-  ///
-  /// The maximum cardinality fractional matching is a relaxation of the
-  /// maximum cardinality matching problem where the odd set constraints
-  /// are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result can be represented as the union of a
-  /// matching with one value edges and a set of odd length cycles
-  /// with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// barrier. The number of adjacents of any node set minus the size
-  /// of node set is a lower bound on the uncovered nodes in the
-  /// graph. For maximum matching a barrier is computed which
-  /// maximizes this difference.
-  ///
-  /// The algorithm can be executed with the run() function.  After it
-  /// the matching (the primal solution) and the barrier (the dual
-  /// solution) can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxFractionalMatching::primalScale "2".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-#ifdef DOXYGEN
-  template <typename GR, typename TR>
-#else
-  template <typename GR,
-            typename TR = MaxFractionalMatchingDefaultTraits<GR> >
-#endif
-  class MaxFractionalMatching {
-  public:
-
-    /// \brief The \ref MaxFractionalMatchingDefaultTraits "traits
-    /// class" of the algorithm.
-    typedef TR Traits;
-    /// The type of the graph the algorithm runs on.
-    typedef typename TR::Graph Graph;
-    /// The type of the matching map.
-    typedef typename TR::MatchingMap MatchingMap;
-    /// The type of the elevator.
-    typedef typename TR::Elevator Elevator;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-  private:
-
-    const Graph &_graph;
-    int _node_num;
-    bool _allow_loops;
-    int _empty_level;
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    bool _local_matching;
-    MatchingMap *_matching;
-
-    bool _local_level;
-    Elevator *_level;
-
-    typedef typename Graph::template NodeMap<int> InDegMap;
-    InDegMap *_indeg;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _local_matching = true;
-        _matching = Traits::createMatchingMap(_graph);
-      }
-      if (!_level) {
-        _local_level = true;
-        _level = Traits::createElevator(_graph, _node_num);
-      }
-      if (!_indeg) {
-        _indeg = new InDegMap(_graph);
-      }
-    }
-
-    void destroyStructures() {
-      if (_local_matching) {
-        delete _matching;
-      }
-      if (_local_level) {
-        delete _level;
-      }
-      if (_indeg) {
-        delete _indeg;
-      }
-    }
-
-    void postprocessing() {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] != 0) continue;
-        _indeg->set(n, -1);
-        Node u = n;
-        while ((*_matching)[u] != INVALID) {
-          Node v = _graph.target((*_matching)[u]);
-          _indeg->set(v, -1);
-          Arc a = _graph.oppositeArc((*_matching)[u]);
-          u = _graph.target((*_matching)[v]);
-          _indeg->set(u, -1);
-          _matching->set(v, a);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] != 1) continue;
-        _indeg->set(n, -1);
-
-        int num = 1;
-        Node u = _graph.target((*_matching)[n]);
-        while (u != n) {
-          _indeg->set(u, -1);
-          u = _graph.target((*_matching)[u]);
-          ++num;
-        }
-        if (num % 2 == 0 && num > 2) {
-          Arc prev = _graph.oppositeArc((*_matching)[n]);
-          Node v = _graph.target((*_matching)[n]);
-          u = _graph.target((*_matching)[v]);
-          _matching->set(v, prev);
-          while (u != n) {
-            prev = _graph.oppositeArc((*_matching)[u]);
-            v = _graph.target((*_matching)[u]);
-            u = _graph.target((*_matching)[v]);
-            _matching->set(v, prev);
-          }
-        }
-      }
-    }
-
-  public:
-
-    typedef MaxFractionalMatching Create;
-
-    ///\name Named Template Parameters
-
-    ///@{
-
-    template <typename T>
-    struct SetMatchingMapTraits : public Traits {
-      typedef T MatchingMap;
-      static MatchingMap *createMatchingMap(const Graph&) {
-        LEMON_ASSERT(false, "MatchingMap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// MatchingMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting MatchingMap
-    /// type.
-    template <typename T>
-    struct SetMatchingMap
-      : public MaxFractionalMatching<Graph, SetMatchingMapTraits<T> > {
-      typedef MaxFractionalMatching<Graph, SetMatchingMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Graph&, int) {
-        LEMON_ASSERT(false, "Elevator is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// Elevator type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting Elevator
-    /// type. If this named parameter is used, then an external
-    /// elevator object must be passed to the algorithm using the
-    /// \ref elevator(Elevator&) "elevator()" function before calling
-    /// \ref run() or \ref init().
-    /// \sa SetStandardElevator
-    template <typename T>
-    struct SetElevator
-      : public MaxFractionalMatching<Graph, SetElevatorTraits<T> > {
-      typedef MaxFractionalMatching<Graph, SetElevatorTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetStandardElevatorTraits : public Traits {
-      typedef T Elevator;
-      static Elevator *createElevator(const Graph& graph, int max_level) {
-        return new Elevator(graph, max_level);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// Elevator type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting Elevator
-    /// type with automatic allocation.
-    /// The Elevator should have standard constructor interface to be
-    /// able to automatically created by the algorithm (i.e. the
-    /// graph and the maximum level should be passed to it).
-    /// However an external elevator object could also be passed to the
-    /// algorithm with the \ref elevator(Elevator&) "elevator()" function
-    /// before calling \ref run() or \ref init().
-    /// \sa SetElevator
-    template <typename T>
-    struct SetStandardElevator
-      : public MaxFractionalMatching<Graph, SetStandardElevatorTraits<T> > {
-      typedef MaxFractionalMatching<Graph,
-                                    SetStandardElevatorTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    MaxFractionalMatching() {}
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    ///
-    MaxFractionalMatching(const Graph &graph, bool allow_loops = true)
-      : _graph(graph), _allow_loops(allow_loops),
-        _local_matching(false), _matching(0),
-        _local_level(false), _level(0),  _indeg(0)
-    {}
-
-    ~MaxFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \brief Sets the matching map.
-    ///
-    /// Sets the matching map.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated map,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    MaxFractionalMatching& matchingMap(MatchingMap& map) {
-      if (_local_matching) {
-        delete _matching;
-        _local_matching = false;
-      }
-      _matching = &map;
-      return *this;
-    }
-
-    /// \brief Sets the elevator used by algorithm.
-    ///
-    /// Sets the elevator used by algorithm.
-    /// If you don't use this function before calling \ref run() or
-    /// \ref init(), an instance will be allocated automatically.
-    /// The destructor deallocates this automatically allocated elevator,
-    /// of course.
-    /// \return <tt>(*this)</tt>
-    MaxFractionalMatching& elevator(Elevator& elevator) {
-      if (_local_level) {
-        delete _level;
-        _local_level = false;
-      }
-      _level = &elevator;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the elevator.
-    ///
-    /// Returns a const reference to the elevator.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const Elevator& elevator() const {
-      return *_level;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use one of the
-    /// member functions called \c run(). \n
-    /// If you need more control on the execution, first
-    /// you must call \ref init() and then one variant of the start()
-    /// member.
-
-    /// @{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures and sets the initial
-    /// matching.
-    void init() {
-      createStructures();
-
-      _level->initStart();
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _indeg->set(n, 0);
-        _matching->set(n, INVALID);
-        _level->initAddItem(n);
-      }
-      _level->initFinish();
-
-      _empty_level = _node_num;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        for (OutArcIt a(_graph, n); a != INVALID; ++a) {
-          if (_graph.target(a) == n && !_allow_loops) continue;
-          _matching->set(n, a);
-          Node v = _graph.target((*_matching)[n]);
-          _indeg->set(v, (*_indeg)[v] + 1);
-          break;
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_indeg)[n] == 0) {
-          _level->activate(n);
-        }
-      }
-    }
-
-    /// \brief Starts the algorithm and computes a fractional matching
-    ///
-    /// The algorithm computes a maximum fractional matching.
-    ///
-    /// \param postprocess The algorithm computes first a matching
-    /// which is a union of a matching with one value edges, cycles
-    /// with half value edges and even length paths with half value
-    /// edges. If the parameter is true, then after the push-relabel
-    /// algorithm it postprocesses the matching to contain only
-    /// matching edges and half value odd cycles.
-    void start(bool postprocess = true) {
-      Node n;
-      while ((n = _level->highestActive()) != INVALID) {
-        int level = _level->highestActiveLevel();
-        int new_level = _level->maxLevel();
-        for (InArcIt a(_graph, n); a != INVALID; ++a) {
-          Node u = _graph.source(a);
-          if (n == u && !_allow_loops) continue;
-          Node v = _graph.target((*_matching)[u]);
-          if ((*_level)[v] < level) {
-            _indeg->set(v, (*_indeg)[v] - 1);
-            if ((*_indeg)[v] == 0) {
-              _level->activate(v);
-            }
-            _matching->set(u, a);
-            _indeg->set(n, (*_indeg)[n] + 1);
-            _level->deactivate(n);
-            goto no_more_push;
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-        if (new_level + 1 < _level->maxLevel()) {
-          _level->liftHighestActive(new_level + 1);
-        } else {
-          _level->liftHighestActiveToTop();
-        }
-        if (_level->emptyLevel(level)) {
-          _level->liftToTop(level);
-        }
-      no_more_push:
-        ;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] == INVALID) continue;
-        Node u = _graph.target((*_matching)[n]);
-        if ((*_indeg)[u] > 1) {
-          _indeg->set(u, (*_indeg)[u] - 1);
-          _matching->set(n, INVALID);
-        }
-      }
-      if (postprocess) {
-        postprocessing();
-      }
-    }
-
-    /// \brief Starts the algorithm and computes a perfect fractional
-    /// matching
-    ///
-    /// The algorithm computes a perfect fractional matching. If it
-    /// does not exists, then the algorithm returns false and the
-    /// matching is undefined and the barrier.
-    ///
-    /// \param postprocess The algorithm computes first a matching
-    /// which is a union of a matching with one value edges, cycles
-    /// with half value edges and even length paths with half value
-    /// edges. If the parameter is true, then after the push-relabel
-    /// algorithm it postprocesses the matching to contain only
-    /// matching edges and half value odd cycles.
-    bool startPerfect(bool postprocess = true) {
-      Node n;
-      while ((n = _level->highestActive()) != INVALID) {
-        int level = _level->highestActiveLevel();
-        int new_level = _level->maxLevel();
-        for (InArcIt a(_graph, n); a != INVALID; ++a) {
-          Node u = _graph.source(a);
-          if (n == u && !_allow_loops) continue;
-          Node v = _graph.target((*_matching)[u]);
-          if ((*_level)[v] < level) {
-            _indeg->set(v, (*_indeg)[v] - 1);
-            if ((*_indeg)[v] == 0) {
-              _level->activate(v);
-            }
-            _matching->set(u, a);
-            _indeg->set(n, (*_indeg)[n] + 1);
-            _level->deactivate(n);
-            goto no_more_push;
-          } else if (new_level > (*_level)[v]) {
-            new_level = (*_level)[v];
-          }
-        }
-
-        if (new_level + 1 < _level->maxLevel()) {
-          _level->liftHighestActive(new_level + 1);
-        } else {
-          _level->liftHighestActiveToTop();
-          _empty_level = _level->maxLevel() - 1;
-          return false;
-        }
-        if (_level->emptyLevel(level)) {
-          _level->liftToTop(level);
-          _empty_level = level;
-          return false;
-        }
-      no_more_push:
-        ;
-      }
-      if (postprocess) {
-        postprocessing();
-      }
-      return true;
-    }
-
-    /// \brief Runs the algorithm
-    ///
-    /// Just a shortcut for the next code:
-    ///\code
-    /// init();
-    /// start();
-    ///\endcode
-    void run(bool postprocess = true) {
-      init();
-      start(postprocess);
-    }
-
-    /// \brief Runs the algorithm to find a perfect fractional matching
-    ///
-    /// Just a shortcut for the next code:
-    ///\code
-    /// init();
-    /// startPerfect();
-    ///\endcode
-    bool runPerfect(bool postprocess = true) {
-      init();
-      return startPerfect(postprocess);
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    /// The result of the %Matching algorithm can be obtained using these
-    /// functions.\n
-    /// Before the use of these functions,
-    /// either run() or start() must be called.
-    ///@{
-
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Returns a const reference to the matching map.
-    ///
-    /// Returns a const reference to the node map storing the found
-    /// fractional matching. This method can be called after
-    /// running the algorithm.
-    ///
-    /// \pre Either \ref run() or \ref init() must be called before
-    /// using this function.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0) +
-        (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Returns true if the node is in the barrier
-    ///
-    /// The barrier is a subset of the nodes. If the nodes in the
-    /// barrier have less adjacent nodes than the size of the barrier,
-    /// then at least as much nodes cannot be covered as the
-    /// difference of the two subsets.
-    bool barrier(const Node& node) const {
-      return (*_level)[node] >= _empty_level;
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted fractional matching in general graphs
-  ///
-  /// This class provides an efficient implementation of fractional
-  /// matching algorithm. The implementation uses priority queues and
-  /// provides \f$O(nm\log n)\f$ time complexity.
-  ///
-  /// The maximum weighted fractional matching is a relaxation of the
-  /// maximum weighted matching problem where the odd set constraints
-  /// are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e \le 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_ew_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result must be the union of a matching with one
-  /// value edges and a set of odd length cycles with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// proof of the optimality. The solution of the dual problem can be
-  /// used to check the result of the algorithm. The dual linear
-  /// problem is the following.
-  /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f]
-  /// \f[y_u \ge 0 \quad \forall u \in V\f]
-  /// \f[\min \sum_{u \in V}y_u \f]
-  ///
-  /// The algorithm can be executed with the run() function.
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxWeightedFractionalMatching::primalScale "2".
-  /// If the value type is integer, then the dual
-  /// solution is scaled by
-  /// \ref MaxWeightedFractionalMatching::dualScale "4".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
-#endif
-  class MaxWeightedFractionalMatching {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The type of the edge weight map
-    typedef WM WeightMap;
-    /// The value type of the edge weights
-    typedef typename WeightMap::Value Value;
-
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-    /// \brief Scaling factor for dual solution
-    ///
-    /// Scaling factor for dual solution. It is equal to 4 or 1
-    /// according to the value type.
-    static const int dualScale =
-      std::numeric_limits<Value>::is_integer ? 4 : 1;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef typename Graph::template NodeMap<Value> NodePotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-    NodePotential* _node_potential;
-
-    int _node_num;
-    bool _allow_loops;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef typename Graph::template NodeMap<Status> StatusMap;
-    StatusMap* _status;
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-    PredMap* _pred;
-
-    typedef ExtendFindEnum<IntNodeMap> TreeSet;
-
-    IntNodeMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntNodeMap *_delta1_index;
-    BinHeap<Value, IntNodeMap> *_delta1;
-
-    IntNodeMap *_delta2_index;
-    BinHeap<Value, IntNodeMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    Value _delta_sum;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-      if (!_status) {
-        _status = new StatusMap(_graph);
-      }
-      if (!_pred) {
-        _pred = new PredMap(_graph);
-      }
-      if (!_tree_set) {
-        _tree_set_index = new IntNodeMap(_graph);
-        _tree_set = new TreeSet(*_tree_set_index);
-      }
-      if (!_delta1) {
-        _delta1_index = new IntNodeMap(_graph);
-        _delta1 = new BinHeap<Value, IntNodeMap>(*_delta1_index);
-      }
-      if (!_delta2) {
-        _delta2_index = new IntNodeMap(_graph);
-        _delta2 = new BinHeap<Value, IntNodeMap>(*_delta2_index);
-      }
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_status) {
-        delete _status;
-      }
-      if (_pred) {
-        delete _pred;
-      }
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-      if (_delta1) {
-        delete _delta1_index;
-        delete _delta1;
-      }
-      if (_delta2) {
-        delete _delta2_index;
-        delete _delta2;
-      }
-      if (_delta3) {
-        delete _delta3_index;
-        delete _delta3;
-      }
-    }
-
-    void matchedToEven(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      _delta1->push(node, (*_node_potential)[node]);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->push(a, rw / 2);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->push(a, rw / 2);
-        } else if ((*_status)[v] == MATCHED) {
-          if (_delta2->state(v) != _delta2->IN_HEAP) {
-            _pred->set(v, a);
-            _delta2->push(v, rw);
-          } else if ((*_delta2)[v] > rw) {
-            _pred->set(v, a);
-            _delta2->decrease(v, rw);
-          }
-        }
-      }
-    }
-
-    void matchedToOdd(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-    }
-
-    void evenToMatched(Node node, int tree) {
-      _delta1->erase(node);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->erase(a);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->erase(a);
-          if (minrw > rw) {
-            min = _graph.oppositeArc(a);
-            minrw = rw;
-          }
-        } else if ((*_status)[v]  == MATCHED) {
-          if ((*_pred)[v] == a) {
-            Arc mina = INVALID;
-            Value minrwa = std::numeric_limits<Value>::max();
-            for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) {
-              Node va = _graph.target(aa);
-              if ((*_status)[va] != EVEN ||
-                  _tree_set->find(va) == tree) continue;
-              Value rwa = (*_node_potential)[v] + (*_node_potential)[va] -
-                dualScale * _weight[aa];
-              if (minrwa > rwa) {
-                minrwa = rwa;
-                mina = aa;
-              }
-            }
-            if (mina != INVALID) {
-              _pred->set(v, mina);
-              _delta2->increase(v, minrwa);
-            } else {
-              _pred->set(v, INVALID);
-              _delta2->erase(v);
-            }
-          }
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void oddToMatched(Node node) {
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        if ((*_status)[v] != EVEN) continue;
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (minrw > rw) {
-          min = _graph.oppositeArc(a);
-          minrw = rw;
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void alternatePath(Node even, int tree) {
-      Node odd;
-
-      _status->set(even, MATCHED);
-      evenToMatched(even, tree);
-
-      Arc prev = (*_matching)[even];
-      while (prev != INVALID) {
-        odd = _graph.target(prev);
-        even = _graph.target((*_pred)[odd]);
-        _matching->set(odd, (*_pred)[odd]);
-        _status->set(odd, MATCHED);
-        oddToMatched(odd);
-
-        prev = (*_matching)[even];
-        _status->set(even, MATCHED);
-        _matching->set(even, _graph.oppositeArc((*_matching)[odd]));
-        evenToMatched(even, tree);
-      }
-    }
-
-    void destroyTree(int tree) {
-      for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) {
-        if ((*_status)[n] == EVEN) {
-          _status->set(n, MATCHED);
-          evenToMatched(n, tree);
-        } else if ((*_status)[n] == ODD) {
-          _status->set(n, MATCHED);
-          oddToMatched(n);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-
-    void unmatchNode(const Node& node) {
-      int tree = _tree_set->find(node);
-
-      alternatePath(node, tree);
-      destroyTree(tree);
-
-      _matching->set(node, INVALID);
-    }
-
-
-    void augmentOnEdge(const Edge& edge) {
-      Node left = _graph.u(edge);
-      int left_tree = _tree_set->find(left);
-
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-      _matching->set(left, _graph.direct(edge, true));
-
-      Node right = _graph.v(edge);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.direct(edge, false));
-    }
-
-    void augmentOnArc(const Arc& arc) {
-      Node left = _graph.source(arc);
-      _status->set(left, MATCHED);
-      _matching->set(left, arc);
-      _pred->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-    void extendOnArc(const Arc& arc) {
-      Node base = _graph.target(arc);
-      int tree = _tree_set->find(base);
-
-      Node odd = _graph.source(arc);
-      _tree_set->insert(odd, tree);
-      _status->set(odd, ODD);
-      matchedToOdd(odd, tree);
-      _pred->set(odd, arc);
-
-      Node even = _graph.target((*_matching)[odd]);
-      _tree_set->insert(even, tree);
-      _status->set(even, EVEN);
-      matchedToEven(even, tree);
-    }
-
-    void cycleOnEdge(const Edge& edge, int tree) {
-      Node nca = INVALID;
-      std::vector<Node> left_path, right_path;
-
-      {
-        std::set<Node> left_set, right_set;
-        Node left = _graph.u(edge);
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        Node right = _graph.v(edge);
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-          if ((*_matching)[left] == INVALID) break;
-
-          left = _graph.target((*_matching)[left]);
-          left_path.push_back(left);
-          left = _graph.target((*_pred)[left]);
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_matching)[right] == INVALID) break;
-
-          right = _graph.target((*_matching)[right]);
-          right_path.push_back(right);
-          right = _graph.target((*_pred)[right]);
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-        }
-
-        if (nca == INVALID) {
-          if ((*_matching)[left] == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              right_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              left_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      alternatePath(nca, tree);
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        _matching->set(left_path[i], prev);
-        _status->set(left_path[i], MATCHED);
-        evenToMatched(left_path[i], tree);
-
-        prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]);
-        _status->set(left_path[i + 1], MATCHED);
-        oddToMatched(left_path[i + 1]);
-      }
-      _matching->set(nca, prev);
-
-      for (int i = 0; right_path[i] != nca; i += 2) {
-        _status->set(right_path[i], MATCHED);
-        evenToMatched(right_path[i], tree);
-
-        _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]);
-        _status->set(right_path[i + 1], MATCHED);
-        oddToMatched(right_path[i + 1]);
-      }
-
-      destroyTree(tree);
-    }
-
-    void extractCycle(const Arc &arc) {
-      Node left = _graph.source(arc);
-      Node odd = _graph.target((*_matching)[left]);
-      Arc prev;
-      while (odd != left) {
-        Node even = _graph.target((*_matching)[odd]);
-        prev = (*_matching)[odd];
-        odd = _graph.target((*_matching)[even]);
-        _matching->set(even, _graph.oppositeArc(prev));
-      }
-      _matching->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedFractionalMatching(const Graph& graph, const WeightMap& weight,
-                                  bool allow_loops = true)
-      : _graph(graph), _weight(weight), _matching(0),
-      _node_potential(0), _node_num(0), _allow_loops(allow_loops),
-      _status(0),  _pred(0),
-      _tree_set_index(0), _tree_set(0),
-
-      _delta1_index(0), _delta1(0),
-      _delta2_index(0), _delta2(0),
-      _delta3_index(0), _delta3(0),
-
-      _delta_sum() {}
-
-    ~MaxWeightedFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
-
-    ///@{
-
-    /// \brief Initialize the algorithm
-    ///
-    /// This function initializes the algorithm.
-    void init() {
-      createStructures();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta1_index)[n] = _delta1->PRE_HEAP;
-        (*_delta2_index)[n] = _delta2->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-
-      _delta1->clear();
-      _delta2->clear();
-      _delta3->clear();
-      _tree_set->clear();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value max = 0;
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          if (_graph.target(e) == n && !_allow_loops) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        _node_potential->set(n, max);
-        _delta1->push(n, max);
-
-        _tree_set->insert(n);
-
-        _matching->set(n, INVALID);
-        _status->set(n, EVEN);
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        Node left = _graph.u(e);
-        Node right = _graph.v(e);
-        if (left == right && !_allow_loops) continue;
-        _delta3->push(e, ((*_node_potential)[left] +
-                          (*_node_potential)[right] -
-                          dualScale * _weight[e]) / 2);
-      }
-    }
-
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
-    void start() {
-      enum OpType {
-        D1, D2, D3
-      };
-
-      int unmatched = _node_num;
-      while (unmatched > 0) {
-        Value d1 = !_delta1->empty() ?
-          _delta1->prio() : std::numeric_limits<Value>::max();
-
-        Value d2 = !_delta2->empty() ?
-          _delta2->prio() : std::numeric_limits<Value>::max();
-
-        Value d3 = !_delta3->empty() ?
-          _delta3->prio() : std::numeric_limits<Value>::max();
-
-        _delta_sum = d3; OpType ot = D3;
-        if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; }
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
-
-        switch (ot) {
-        case D1:
-          {
-            Node n = _delta1->top();
-            unmatchNode(n);
-            --unmatched;
-          }
-          break;
-        case D2:
-          {
-            Node n = _delta2->top();
-            Arc a = (*_pred)[n];
-            if ((*_matching)[n] == INVALID) {
-              augmentOnArc(a);
-              --unmatched;
-            } else {
-              Node v = _graph.target((*_matching)[n]);
-              if ((*_matching)[n] !=
-                  _graph.oppositeArc((*_matching)[v])) {
-                extractCycle(a);
-                --unmatched;
-              } else {
-                extendOnArc(a);
-              }
-            }
-          } break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            Node left = _graph.u(e);
-            Node right = _graph.v(e);
-
-            int left_tree = _tree_set->find(left);
-            int right_tree = _tree_set->find(right);
-
-            if (left_tree == right_tree) {
-              cycleOnEdge(e, left_tree);
-              --unmatched;
-            } else {
-              augmentOnEdge(e);
-              unmatched -= 2;
-            }
-          } break;
-        }
-      }
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedFractionalMatching algorithm.
-    ///
-    /// \note mwfm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwfm.init();
-    ///   mwfm.start();
-    /// \endcode
-    void run() {
-      init();
-      start();
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
-    /// matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching. This
-    /// value is scaled by \ref primalScale "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value matchingWeight() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          sum += _weight[(*_matching)[n]];
-        }
-      }
-      return sum * primalScale / 2;
-    }
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0)
-        + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Return a const reference to the matching map.
-    ///
-    /// This function returns a const reference to a node map that stores
-    /// the matching arc (or edge) incident to each node.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// @}
-
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value dualValue() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sum += nodeValue(n);
-      }
-      return sum;
-    }
-
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value nodeValue(const Node& n) const {
-      return (*_node_potential)[n];
-    }
-
-    /// @}
-
-  };
-
-  /// \ingroup matching
-  ///
-  /// \brief Weighted fractional perfect matching in general graphs
-  ///
-  /// This class provides an efficient implementation of fractional
-  /// matching algorithm. The implementation uses priority queues and
-  /// provides \f$O(nm\log n)\f$ time complexity.
-  ///
-  /// The maximum weighted fractional perfect matching is a relaxation
-  /// of the maximum weighted perfect matching problem where the odd
-  /// set constraints are omitted.
-  /// It can be formulated with the following linear program.
-  /// \f[ \sum_{e \in \delta(u)}x_e = 1 \quad \forall u\in V\f]
-  /// \f[x_e \ge 0\quad \forall e\in E\f]
-  /// \f[\max \sum_{e\in E}x_ew_e\f]
-  /// where \f$\delta(X)\f$ is the set of edges incident to a node in
-  /// \f$X\f$. The result must be the union of a matching with one
-  /// value edges and a set of odd length cycles with half value edges.
-  ///
-  /// The algorithm calculates an optimal fractional matching and a
-  /// proof of the optimality. The solution of the dual problem can be
-  /// used to check the result of the algorithm. The dual linear
-  /// problem is the following.
-  /// \f[ y_u + y_v \ge w_{uv} \quad \forall uv\in E\f]
-  /// \f[\min \sum_{u \in V}y_u \f]
-  ///
-  /// The algorithm can be executed with the run() function.
-  /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions.
-  ///
-  /// The primal solution is multiplied by
-  /// \ref MaxWeightedPerfectFractionalMatching::primalScale "2".
-  /// If the value type is integer, then the dual
-  /// solution is scaled by
-  /// \ref MaxWeightedPerfectFractionalMatching::dualScale "4".
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
-  /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
-#ifdef DOXYGEN
-  template <typename GR, typename WM>
-#else
-  template <typename GR,
-            typename WM = typename GR::template EdgeMap<int> >
-#endif
-  class MaxWeightedPerfectFractionalMatching {
-  public:
-
-    /// The graph type of the algorithm
-    typedef GR Graph;
-    /// The type of the edge weight map
-    typedef WM WeightMap;
-    /// The value type of the edge weights
-    typedef typename WeightMap::Value Value;
-
-    /// The type of the matching map
-    typedef typename Graph::template NodeMap<typename Graph::Arc>
-    MatchingMap;
-
-    /// \brief Scaling factor for primal solution
-    ///
-    /// Scaling factor for primal solution.
-    static const int primalScale = 2;
-
-    /// \brief Scaling factor for dual solution
-    ///
-    /// Scaling factor for dual solution. It is equal to 4 or 1
-    /// according to the value type.
-    static const int dualScale =
-      std::numeric_limits<Value>::is_integer ? 4 : 1;
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    typedef typename Graph::template NodeMap<Value> NodePotential;
-
-    const Graph& _graph;
-    const WeightMap& _weight;
-
-    MatchingMap* _matching;
-    NodePotential* _node_potential;
-
-    int _node_num;
-    bool _allow_loops;
-
-    enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
-    };
-
-    typedef typename Graph::template NodeMap<Status> StatusMap;
-    StatusMap* _status;
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-    PredMap* _pred;
-
-    typedef ExtendFindEnum<IntNodeMap> TreeSet;
-
-    IntNodeMap *_tree_set_index;
-    TreeSet *_tree_set;
-
-    IntNodeMap *_delta2_index;
-    BinHeap<Value, IntNodeMap> *_delta2;
-
-    IntEdgeMap *_delta3_index;
-    BinHeap<Value, IntEdgeMap> *_delta3;
-
-    Value _delta_sum;
-
-    void createStructures() {
-      _node_num = countNodes(_graph);
-
-      if (!_matching) {
-        _matching = new MatchingMap(_graph);
-      }
-      if (!_node_potential) {
-        _node_potential = new NodePotential(_graph);
-      }
-      if (!_status) {
-        _status = new StatusMap(_graph);
-      }
-      if (!_pred) {
-        _pred = new PredMap(_graph);
-      }
-      if (!_tree_set) {
-        _tree_set_index = new IntNodeMap(_graph);
-        _tree_set = new TreeSet(*_tree_set_index);
-      }
-      if (!_delta2) {
-        _delta2_index = new IntNodeMap(_graph);
-        _delta2 = new BinHeap<Value, IntNodeMap>(*_delta2_index);
-      }
-      if (!_delta3) {
-        _delta3_index = new IntEdgeMap(_graph);
-        _delta3 = new BinHeap<Value, IntEdgeMap>(*_delta3_index);
-      }
-    }
-
-    void destroyStructures() {
-      if (_matching) {
-        delete _matching;
-      }
-      if (_node_potential) {
-        delete _node_potential;
-      }
-      if (_status) {
-        delete _status;
-      }
-      if (_pred) {
-        delete _pred;
-      }
-      if (_tree_set) {
-        delete _tree_set_index;
-        delete _tree_set;
-      }
-      if (_delta2) {
-        delete _delta2_index;
-        delete _delta2;
-      }
-      if (_delta3) {
-        delete _delta3_index;
-        delete _delta3;
-      }
-    }
-
-    void matchedToEven(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->push(a, rw / 2);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->push(a, rw / 2);
-        } else if ((*_status)[v] == MATCHED) {
-          if (_delta2->state(v) != _delta2->IN_HEAP) {
-            _pred->set(v, a);
-            _delta2->push(v, rw);
-          } else if ((*_delta2)[v] > rw) {
-            _pred->set(v, a);
-            _delta2->decrease(v, rw);
-          }
-        }
-      }
-    }
-
-    void matchedToOdd(Node node, int tree) {
-      _tree_set->insert(node, tree);
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-
-      if (_delta2->state(node) == _delta2->IN_HEAP) {
-        _delta2->erase(node);
-      }
-    }
-
-    void evenToMatched(Node node, int tree) {
-      _node_potential->set(node, (*_node_potential)[node] - _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (node == v) {
-          if (_allow_loops && _graph.direction(a)) {
-            _delta3->erase(a);
-          }
-        } else if ((*_status)[v] == EVEN) {
-          _delta3->erase(a);
-          if (minrw > rw) {
-            min = _graph.oppositeArc(a);
-            minrw = rw;
-          }
-        } else if ((*_status)[v]  == MATCHED) {
-          if ((*_pred)[v] == a) {
-            Arc mina = INVALID;
-            Value minrwa = std::numeric_limits<Value>::max();
-            for (OutArcIt aa(_graph, v); aa != INVALID; ++aa) {
-              Node va = _graph.target(aa);
-              if ((*_status)[va] != EVEN ||
-                  _tree_set->find(va) == tree) continue;
-              Value rwa = (*_node_potential)[v] + (*_node_potential)[va] -
-                dualScale * _weight[aa];
-              if (minrwa > rwa) {
-                minrwa = rwa;
-                mina = aa;
-              }
-            }
-            if (mina != INVALID) {
-              _pred->set(v, mina);
-              _delta2->increase(v, minrwa);
-            } else {
-              _pred->set(v, INVALID);
-              _delta2->erase(v);
-            }
-          }
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void oddToMatched(Node node) {
-      _node_potential->set(node, (*_node_potential)[node] + _delta_sum);
-      Arc min = INVALID;
-      Value minrw = std::numeric_limits<Value>::max();
-      for (InArcIt a(_graph, node); a != INVALID; ++a) {
-        Node v = _graph.source(a);
-        if ((*_status)[v] != EVEN) continue;
-        Value rw = (*_node_potential)[node] + (*_node_potential)[v] -
-          dualScale * _weight[a];
-
-        if (minrw > rw) {
-          min = _graph.oppositeArc(a);
-          minrw = rw;
-        }
-      }
-      if (min != INVALID) {
-        _pred->set(node, min);
-        _delta2->push(node, minrw);
-      } else {
-        _pred->set(node, INVALID);
-      }
-    }
-
-    void alternatePath(Node even, int tree) {
-      Node odd;
-
-      _status->set(even, MATCHED);
-      evenToMatched(even, tree);
-
-      Arc prev = (*_matching)[even];
-      while (prev != INVALID) {
-        odd = _graph.target(prev);
-        even = _graph.target((*_pred)[odd]);
-        _matching->set(odd, (*_pred)[odd]);
-        _status->set(odd, MATCHED);
-        oddToMatched(odd);
-
-        prev = (*_matching)[even];
-        _status->set(even, MATCHED);
-        _matching->set(even, _graph.oppositeArc((*_matching)[odd]));
-        evenToMatched(even, tree);
-      }
-    }
-
-    void destroyTree(int tree) {
-      for (typename TreeSet::ItemIt n(*_tree_set, tree); n != INVALID; ++n) {
-        if ((*_status)[n] == EVEN) {
-          _status->set(n, MATCHED);
-          evenToMatched(n, tree);
-        } else if ((*_status)[n] == ODD) {
-          _status->set(n, MATCHED);
-          oddToMatched(n);
-        }
-      }
-      _tree_set->eraseClass(tree);
-    }
-
-    void augmentOnEdge(const Edge& edge) {
-      Node left = _graph.u(edge);
-      int left_tree = _tree_set->find(left);
-
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-      _matching->set(left, _graph.direct(edge, true));
-
-      Node right = _graph.v(edge);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.direct(edge, false));
-    }
-
-    void augmentOnArc(const Arc& arc) {
-      Node left = _graph.source(arc);
-      _status->set(left, MATCHED);
-      _matching->set(left, arc);
-      _pred->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-    void extendOnArc(const Arc& arc) {
-      Node base = _graph.target(arc);
-      int tree = _tree_set->find(base);
-
-      Node odd = _graph.source(arc);
-      _tree_set->insert(odd, tree);
-      _status->set(odd, ODD);
-      matchedToOdd(odd, tree);
-      _pred->set(odd, arc);
-
-      Node even = _graph.target((*_matching)[odd]);
-      _tree_set->insert(even, tree);
-      _status->set(even, EVEN);
-      matchedToEven(even, tree);
-    }
-
-    void cycleOnEdge(const Edge& edge, int tree) {
-      Node nca = INVALID;
-      std::vector<Node> left_path, right_path;
-
-      {
-        std::set<Node> left_set, right_set;
-        Node left = _graph.u(edge);
-        left_path.push_back(left);
-        left_set.insert(left);
-
-        Node right = _graph.v(edge);
-        right_path.push_back(right);
-        right_set.insert(right);
-
-        while (true) {
-
-          if (left_set.find(right) != left_set.end()) {
-            nca = right;
-            break;
-          }
-
-          if ((*_matching)[left] == INVALID) break;
-
-          left = _graph.target((*_matching)[left]);
-          left_path.push_back(left);
-          left = _graph.target((*_pred)[left]);
-          left_path.push_back(left);
-
-          left_set.insert(left);
-
-          if (right_set.find(left) != right_set.end()) {
-            nca = left;
-            break;
-          }
-
-          if ((*_matching)[right] == INVALID) break;
-
-          right = _graph.target((*_matching)[right]);
-          right_path.push_back(right);
-          right = _graph.target((*_pred)[right]);
-          right_path.push_back(right);
-
-          right_set.insert(right);
-
-        }
-
-        if (nca == INVALID) {
-          if ((*_matching)[left] == INVALID) {
-            nca = right;
-            while (left_set.find(nca) == left_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              right_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              right_path.push_back(nca);
-            }
-          } else {
-            nca = left;
-            while (right_set.find(nca) == right_set.end()) {
-              nca = _graph.target((*_matching)[nca]);
-              left_path.push_back(nca);
-              nca = _graph.target((*_pred)[nca]);
-              left_path.push_back(nca);
-            }
-          }
-        }
-      }
-
-      alternatePath(nca, tree);
-      Arc prev;
-
-      prev = _graph.direct(edge, true);
-      for (int i = 0; left_path[i] != nca; i += 2) {
-        _matching->set(left_path[i], prev);
-        _status->set(left_path[i], MATCHED);
-        evenToMatched(left_path[i], tree);
-
-        prev = _graph.oppositeArc((*_pred)[left_path[i + 1]]);
-        _status->set(left_path[i + 1], MATCHED);
-        oddToMatched(left_path[i + 1]);
-      }
-      _matching->set(nca, prev);
-
-      for (int i = 0; right_path[i] != nca; i += 2) {
-        _status->set(right_path[i], MATCHED);
-        evenToMatched(right_path[i], tree);
-
-        _matching->set(right_path[i + 1], (*_pred)[right_path[i + 1]]);
-        _status->set(right_path[i + 1], MATCHED);
-        oddToMatched(right_path[i + 1]);
-      }
-
-      destroyTree(tree);
-    }
-
-    void extractCycle(const Arc &arc) {
-      Node left = _graph.source(arc);
-      Node odd = _graph.target((*_matching)[left]);
-      Arc prev;
-      while (odd != left) {
-        Node even = _graph.target((*_matching)[odd]);
-        prev = (*_matching)[odd];
-        odd = _graph.target((*_matching)[even]);
-        _matching->set(even, _graph.oppositeArc(prev));
-      }
-      _matching->set(left, arc);
-
-      Node right = _graph.target(arc);
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-      _matching->set(right, _graph.oppositeArc(arc));
-    }
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    MaxWeightedPerfectFractionalMatching(const Graph& graph,
-                                         const WeightMap& weight,
-                                         bool allow_loops = true)
-      : _graph(graph), _weight(weight), _matching(0),
-      _node_potential(0), _node_num(0), _allow_loops(allow_loops),
-      _status(0),  _pred(0),
-      _tree_set_index(0), _tree_set(0),
-
-      _delta2_index(0), _delta2(0),
-      _delta3_index(0), _delta3(0),
-
-      _delta_sum() {}
-
-    ~MaxWeightedPerfectFractionalMatching() {
-      destroyStructures();
-    }
-
-    /// \name Execution Control
-    /// The simplest way to execute the algorithm is to use the
-    /// \ref run() member function.
-
-    ///@{
-
-    /// \brief Initialize the algorithm
-    ///
-    /// This function initializes the algorithm.
-    void init() {
-      createStructures();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta2_index)[n] = _delta2->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-
-      _delta2->clear();
-      _delta3->clear();
-      _tree_set->clear();
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value max = - std::numeric_limits<Value>::max();
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          if (_graph.target(e) == n && !_allow_loops) continue;
-          if ((dualScale * _weight[e]) / 2 > max) {
-            max = (dualScale * _weight[e]) / 2;
-          }
-        }
-        _node_potential->set(n, max);
-
-        _tree_set->insert(n);
-
-        _matching->set(n, INVALID);
-        _status->set(n, EVEN);
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        Node left = _graph.u(e);
-        Node right = _graph.v(e);
-        if (left == right && !_allow_loops) continue;
-        _delta3->push(e, ((*_node_potential)[left] +
-                          (*_node_potential)[right] -
-                          dualScale * _weight[e]) / 2);
-      }
-    }
-
-    /// \brief Start the algorithm
-    ///
-    /// This function starts the algorithm.
-    ///
-    /// \pre \ref init() must be called before using this function.
-    bool start() {
-      enum OpType {
-        D2, D3
-      };
-
-      int unmatched = _node_num;
-      while (unmatched > 0) {
-        Value d2 = !_delta2->empty() ?
-          _delta2->prio() : std::numeric_limits<Value>::max();
-
-        Value d3 = !_delta3->empty() ?
-          _delta3->prio() : std::numeric_limits<Value>::max();
-
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
-
-        if (_delta_sum == std::numeric_limits<Value>::max()) {
-          return false;
-        }
-
-        switch (ot) {
-        case D2:
-          {
-            Node n = _delta2->top();
-            Arc a = (*_pred)[n];
-            if ((*_matching)[n] == INVALID) {
-              augmentOnArc(a);
-              --unmatched;
-            } else {
-              Node v = _graph.target((*_matching)[n]);
-              if ((*_matching)[n] !=
-                  _graph.oppositeArc((*_matching)[v])) {
-                extractCycle(a);
-                --unmatched;
-              } else {
-                extendOnArc(a);
-              }
-            }
-          } break;
-        case D3:
-          {
-            Edge e = _delta3->top();
-
-            Node left = _graph.u(e);
-            Node right = _graph.v(e);
-
-            int left_tree = _tree_set->find(left);
-            int right_tree = _tree_set->find(right);
-
-            if (left_tree == right_tree) {
-              cycleOnEdge(e, left_tree);
-              --unmatched;
-            } else {
-              augmentOnEdge(e);
-              unmatched -= 2;
-            }
-          } break;
-        }
-      }
-      return true;
-    }
-
-    /// \brief Run the algorithm.
-    ///
-    /// This method runs the \c %MaxWeightedPerfectFractionalMatching
-    /// algorithm.
-    ///
-    /// \note mwfm.run() is just a shortcut of the following code.
-    /// \code
-    ///   mwpfm.init();
-    ///   mwpfm.start();
-    /// \endcode
-    bool run() {
-      init();
-      return start();
-    }
-
-    /// @}
-
-    /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
-    /// matching.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the weight of the matching.
-    ///
-    /// This function returns the weight of the found matching. This
-    /// value is scaled by \ref primalScale "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value matchingWeight() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          sum += _weight[(*_matching)[n]];
-        }
-      }
-      return sum * primalScale / 2;
-    }
-
-    /// \brief Return the number of covered nodes in the matching.
-    ///
-    /// This function returns the number of covered nodes in the matching.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matchingSize() const {
-      int num = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if ((*_matching)[n] != INVALID) {
-          ++num;
-        }
-      }
-      return num;
-    }
-
-    /// \brief Return \c true if the given edge is in the matching.
-    ///
-    /// This function returns \c true if the given edge is in the
-    /// found matching. The result is scaled by \ref primalScale
-    /// "primal scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    int matching(const Edge& edge) const {
-      return (edge == (*_matching)[_graph.u(edge)] ? 1 : 0)
-        + (edge == (*_matching)[_graph.v(edge)] ? 1 : 0);
-    }
-
-    /// \brief Return the fractional matching arc (or edge) incident
-    /// to the given node.
-    ///
-    /// This function returns one of the fractional matching arc (or
-    /// edge) incident to the given node in the found matching or \c
-    /// INVALID if the node is not covered by the matching or if the
-    /// node is on an odd length cycle then it is the successor edge
-    /// on the cycle.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Arc matching(const Node& node) const {
-      return (*_matching)[node];
-    }
-
-    /// \brief Return a const reference to the matching map.
-    ///
-    /// This function returns a const reference to a node map that stores
-    /// the matching arc (or edge) incident to each node.
-    const MatchingMap& matchingMap() const {
-      return *_matching;
-    }
-
-    /// @}
-
-    /// \name Dual Solution
-    /// Functions to get the dual solution.\n
-    /// Either \ref run() or \ref start() function should be called before
-    /// using them.
-
-    /// @{
-
-    /// \brief Return the value of the dual solution.
-    ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
-    /// "dual scale".
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value dualValue() const {
-      Value sum = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        sum += nodeValue(n);
-      }
-      return sum;
-    }
-
-    /// \brief Return the dual value (potential) of the given node.
-    ///
-    /// This function returns the dual value (potential) of the given node.
-    ///
-    /// \pre Either run() or start() must be called before using this function.
-    Value nodeValue(const Node& n) const {
-      return (*_node_potential)[n];
-    }
-
-    /// @}
-
-  };
-
-} //END OF NAMESPACE LEMON
-
-#endif //LEMON_FRACTIONAL_MATCHING_H
Index: lemon/full_graph.h
===================================================================
--- lemon/full_graph.h	(revision 877)
+++ lemon/full_graph.h	(revision 617)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -25,5 +25,5 @@
 ///\ingroup graphs
 ///\file
-///\brief FullDigraph and FullGraph classes.
+///\brief FullGraph and FullDigraph classes.
 
 namespace lemon {
@@ -52,5 +52,5 @@
 
     Node operator()(int ix) const { return Node(ix); }
-    static int index(const Node& node) { return node._id; }
+    int index(const Node& node) const { return node._id; }
 
     Arc arc(const Node& s, const Node& t) const {
@@ -149,26 +149,22 @@
   /// \ingroup graphs
   ///
-  /// \brief A directed full graph class.
-  ///
-  /// FullDigraph is a simple and fast implmenetation of directed full
-  /// (complete) graphs. It contains an arc from each node to each node
-  /// (including a loop for each node), therefore the number of arcs
-  /// is the square of the number of nodes.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or arcs, however
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes and arcs.
-  ///
-  /// \note FullDigraph and FullGraph classes are very similar,
+  /// \brief A full digraph class.
+  ///
+  /// This is a simple and fast directed full graph implementation.
+  /// From each node go arcs to each node (including the source node),
+  /// therefore the number of the arcs in the digraph is the square of
+  /// the node number. This digraph type is completely static, so you
+  /// can neither add nor delete either arcs or nodes, and it needs
+  /// constant space in memory.
+  ///
+  /// This class fully conforms to the \ref concepts::Digraph
+  /// "Digraph concept".
+  ///
+  /// The \c FullDigraph and \c FullGraph classes are very similar,
   /// but there are two differences. While this class conforms only
-  /// to the \ref concepts::Digraph "Digraph" concept, FullGraph
-  /// conforms to the \ref concepts::Graph "Graph" concept,
-  /// moreover FullGraph does not contain a loop for each
-  /// node as this class does.
+  /// to the \ref concepts::Digraph "Digraph" concept, the \c FullGraph
+  /// class conforms to the \ref concepts::Graph "Graph" concept,
+  /// moreover \c FullGraph does not contain a loop arc for each
+  /// node as \c FullDigraph does.
   ///
   /// \sa FullGraph
@@ -178,7 +174,5 @@
   public:
 
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and arcs will be zero.
+    /// \brief Constructor
     FullDigraph() { construct(0); }
 
@@ -191,6 +185,6 @@
     /// \brief Resizes the digraph
     ///
-    /// This function resizes the digraph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the digraph will be
+    /// Resizes the digraph. The function will fully destroy and
+    /// rebuild the digraph. This cause that the maps of the digraph will
     /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
@@ -204,8 +198,7 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
+    /// Returns the node with the given index. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -213,15 +206,14 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
-    /// \sa operator()()
-    static int index(const Node& node) { return Parent::index(node); }
+    /// Returns the index of the given node. Since it is a static
+    /// digraph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \sa operator()
+    int index(const Node& node) const { return Parent::index(node); }
 
     /// \brief Returns the arc connecting the given nodes.
     ///
     /// Returns the arc connecting the given nodes.
-    Arc arc(Node u, Node v) const {
+    Arc arc(const Node& u, const Node& v) const {
       return Parent::arc(u, v);
     }
@@ -292,5 +284,5 @@
 
     Node operator()(int ix) const { return Node(ix); }
-    static int index(const Node& node) { return node._id; }
+    int index(const Node& node) const { return node._id; }
 
     Edge edge(const Node& u, const Node& v) const {
@@ -529,23 +521,19 @@
   /// \brief An undirected full graph class.
   ///
-  /// FullGraph is a simple and fast implmenetation of undirected full
-  /// (complete) graphs. It contains an edge between every distinct pair
-  /// of nodes, therefore the number of edges is <tt>n(n-1)/2</tt>.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \note FullDigraph and FullGraph classes are very similar,
-  /// but there are two differences. While FullDigraph
+  /// This is a simple and fast undirected full graph
+  /// implementation. From each node go edge to each other node,
+  /// therefore the number of edges in the graph is \f$n(n-1)/2\f$.
+  /// This graph type is completely static, so you can neither
+  /// add nor delete either edges or nodes, and it needs constant
+  /// space in memory.
+  ///
+  /// This class fully conforms to the \ref concepts::Graph "Graph concept".
+  ///
+  /// The \c FullGraph and \c FullDigraph classes are very similar,
+  /// but there are two differences. While the \c FullDigraph class
   /// conforms only to the \ref concepts::Digraph "Digraph" concept,
   /// this class conforms to the \ref concepts::Graph "Graph" concept,
-  /// moreover this class does not contain a loop for each
-  /// node as FullDigraph does.
+  /// moreover \c FullGraph does not contain a loop arc for each
+  /// node as \c FullDigraph does.
   ///
   /// \sa FullDigraph
@@ -555,7 +543,5 @@
   public:
 
-    /// \brief Default constructor.
-    ///
-    /// Default constructor. The number of nodes and edges will be zero.
+    /// \brief Constructor
     FullGraph() { construct(0); }
 
@@ -568,6 +554,6 @@
     /// \brief Resizes the graph
     ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
+    /// Resizes the graph. The function will fully destroy and
+    /// rebuild the graph. This cause that the maps of the graph will
     /// reallocated automatically and the previous values will be lost.
     void resize(int n) {
@@ -583,8 +569,7 @@
     /// \brief Returns the node with the given index.
     ///
-    /// Returns the node with the given index. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
+    /// Returns the node with the given index. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
     /// \sa index()
     Node operator()(int ix) const { return Parent::operator()(ix); }
@@ -592,22 +577,21 @@
     /// \brief Returns the index of the given node.
     ///
-    /// Returns the index of the given node. Since this structure is
-    /// completely static, the nodes can be indexed with integers from
-    /// the range <tt>[0..nodeNum()-1]</tt>.
-    /// The index of a node is the same as its ID.
-    /// \sa operator()()
-    static int index(const Node& node) { return Parent::index(node); }
+    /// Returns the index of the given node. Since it is a static
+    /// graph its nodes can be indexed with integers from the range
+    /// <tt>[0..nodeNum()-1]</tt>.
+    /// \sa operator()
+    int index(const Node& node) const { return Parent::index(node); }
 
     /// \brief Returns the arc connecting the given nodes.
     ///
     /// Returns the arc connecting the given nodes.
-    Arc arc(Node s, Node t) const {
+    Arc arc(const Node& s, const Node& t) const {
       return Parent::arc(s, t);
     }
 
-    /// \brief Returns the edge connecting the given nodes.
-    ///
-    /// Returns the edge connecting the given nodes.
-    Edge edge(Node u, Node v) const {
+    /// \brief Returns the edge connects the given nodes.
+    ///
+    /// Returns the edge connects the given nodes.
+    Edge edge(const Node& u, const Node& v) const {
       return Parent::edge(u, v);
     }
Index: lemon/glpk.cc
===================================================================
--- lemon/glpk.cc	(revision 989)
+++ lemon/glpk.cc	(revision 988)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -57,40 +57,4 @@
     int i = glp_add_rows(lp, 1);
     glp_set_row_bnds(lp, i, GLP_FR, 0.0, 0.0);
-    return i;
-  }
-
-  int GlpkBase::_addRow(Value lo, ExprIterator b,
-                        ExprIterator e, Value up) {
-    int i = glp_add_rows(lp, 1);
-
-    if (lo == -INF) {
-      if (up == INF) {
-        glp_set_row_bnds(lp, i, GLP_FR, lo, up);
-      } else {
-        glp_set_row_bnds(lp, i, GLP_UP, lo, up);
-      }
-    } else {
-      if (up == INF) {
-        glp_set_row_bnds(lp, i, GLP_LO, lo, up);
-      } else if (lo != up) {
-        glp_set_row_bnds(lp, i, GLP_DB, lo, up);
-      } else {
-        glp_set_row_bnds(lp, i, GLP_FX, lo, up);
-      }
-    }
-
-    std::vector<int> indexes;
-    std::vector<Value> values;
-
-    indexes.push_back(0);
-    values.push_back(0);
-
-    for(ExprIterator it = b; it != e; ++it) {
-      indexes.push_back(it->first);
-      values.push_back(it->second);
-    }
-
-    glp_set_mat_row(lp, i, values.size() - 1,
-                    &indexes.front(), &values.front());
     return i;
   }
Index: lemon/glpk.h
===================================================================
--- lemon/glpk.h	(revision 877)
+++ lemon/glpk.h	(revision 832)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -31,5 +31,5 @@
     class VoidPtr {
     private:
-      void *_ptr;
+      void *_ptr;      
     public:
       VoidPtr() : _ptr(0) {}
@@ -39,6 +39,6 @@
 
       template <typename T>
-      VoidPtr& operator=(T* ptr) {
-        _ptr = reinterpret_cast<void*>(ptr);
+      VoidPtr& operator=(T* ptr) { 
+        _ptr = reinterpret_cast<void*>(ptr); 
         return *this;
       }
@@ -66,5 +66,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
@@ -125,11 +124,11 @@
       }
     };
-
+    
     static FreeEnvHelper freeEnvHelper;
 
   protected:
-
+    
     int _message_level;
-
+    
   public:
 
Index: lemon/gomory_hu.h
===================================================================
--- lemon/gomory_hu.h	(revision 877)
+++ lemon/gomory_hu.h	(revision 596)
@@ -1,7 +1,7 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
+/* -*- C++ -*-
  *
- * 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-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -28,5 +28,5 @@
 
 /// \ingroup min_cut
-/// \file
+/// \file 
 /// \brief Gomory-Hu cut tree in graphs.
 
@@ -39,5 +39,5 @@
   /// The Gomory-Hu tree is a tree on the node set of a given graph, but it
   /// may contain edges which are not in the original graph. It has the
-  /// property that the minimum capacity edge of the path between two nodes
+  /// property that the minimum capacity edge of the path between two nodes 
   /// in this tree has the same weight as the minimum cut in the graph
   /// between these nodes. Moreover the components obtained by removing
@@ -45,5 +45,5 @@
   /// Therefore once this tree is computed, the minimum cut between any pair
   /// of nodes can easily be obtained.
-  ///
+  /// 
   /// The algorithm calculates \e n-1 distinct minimum cuts (currently with
   /// the \ref Preflow algorithm), thus it has \f$O(n^3\sqrt{e})\f$ overall
@@ -61,8 +61,8 @@
 #ifdef DOXYGEN
   template <typename GR,
-            typename CAP>
+	    typename CAP>
 #else
   template <typename GR,
-            typename CAP = typename GR::template EdgeMap<int> >
+	    typename CAP = typename GR::template EdgeMap<int> >
 #endif
   class GomoryHu {
@@ -75,5 +75,5 @@
     /// The value type of capacities
     typedef typename Capacity::Value Value;
-
+    
   private:
 
@@ -90,11 +90,11 @@
     void createStructures() {
       if (!_pred) {
-        _pred = new typename Graph::template NodeMap<Node>(_graph);
+	_pred = new typename Graph::template NodeMap<Node>(_graph);
       }
       if (!_weight) {
-        _weight = new typename Graph::template NodeMap<Value>(_graph);
+	_weight = new typename Graph::template NodeMap<Value>(_graph);
       }
       if (!_order) {
-        _order = new typename Graph::template NodeMap<int>(_graph);
+	_order = new typename Graph::template NodeMap<int>(_graph);
       }
     }
@@ -102,14 +102,14 @@
     void destroyStructures() {
       if (_pred) {
-        delete _pred;
+	delete _pred;
       }
       if (_weight) {
-        delete _weight;
+	delete _weight;
       }
       if (_order) {
-        delete _order;
-      }
-    }
-
+	delete _order;
+      }
+    }
+  
   public:
 
@@ -119,7 +119,7 @@
     /// \param graph The undirected graph the algorithm runs on.
     /// \param capacity The edge capacity map.
-    GomoryHu(const Graph& graph, const Capacity& capacity)
+    GomoryHu(const Graph& graph, const Capacity& capacity) 
       : _graph(graph), _capacity(capacity),
-        _pred(0), _weight(0), _order(0)
+	_pred(0), _weight(0), _order(0) 
     {
       checkConcept<concepts::ReadMap<Edge, Value>, Capacity>();
@@ -135,5 +135,5 @@
 
   private:
-
+  
     // Initialize the internal data structures
     void init() {
@@ -146,5 +146,5 @@
       }
       (*_pred)[_root] = INVALID;
-      (*_weight)[_root] = std::numeric_limits<Value>::max();
+      (*_weight)[_root] = std::numeric_limits<Value>::max(); 
     }
 
@@ -155,25 +155,25 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (n == _root) continue;
-
-        Node pn = (*_pred)[n];
-        fa.source(n);
-        fa.target(pn);
-
-        fa.runMinCut();
-
-        (*_weight)[n] = fa.flowValue();
-
-        for (NodeIt nn(_graph); nn != INVALID; ++nn) {
-          if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
-            (*_pred)[nn] = n;
-          }
-        }
-        if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
-          (*_pred)[n] = (*_pred)[pn];
-          (*_pred)[pn] = n;
-          (*_weight)[n] = (*_weight)[pn];
-          (*_weight)[pn] = fa.flowValue();
-        }
+	if (n == _root) continue;
+
+	Node pn = (*_pred)[n];
+	fa.source(n);
+	fa.target(pn);
+
+	fa.runMinCut();
+
+	(*_weight)[n] = fa.flowValue();
+
+	for (NodeIt nn(_graph); nn != INVALID; ++nn) {
+	  if (nn != n && fa.minCut(nn) && (*_pred)[nn] == pn) {
+	    (*_pred)[nn] = n;
+	  }
+	}
+	if ((*_pred)[pn] != INVALID && fa.minCut((*_pred)[pn])) {
+	  (*_pred)[n] = (*_pred)[pn];
+	  (*_pred)[pn] = n;
+	  (*_weight)[n] = (*_weight)[pn];
+	  (*_weight)[pn] = fa.flowValue();
+	}
       }
 
@@ -182,14 +182,14 @@
 
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        std::vector<Node> st;
-        Node nn = n;
-        while ((*_order)[nn] == -1) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          (*_order)[st.back()] = index++;
-          st.pop_back();
-        }
+	std::vector<Node> st;
+	Node nn = n;
+	while ((*_order)[nn] == -1) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  (*_order)[st.back()] = index++;
+	  st.pop_back();
+	}
       }
     }
@@ -198,5 +198,5 @@
 
     ///\name Execution Control
-
+ 
     ///@{
 
@@ -208,5 +208,5 @@
       start();
     }
-
+    
     /// @}
 
@@ -233,5 +233,5 @@
     /// Gomory-Hu tree.
     ///
-    /// This function returns the weight of the predecessor edge of the
+    /// This function returns the weight of the predecessor edge of the 
     /// given node in the Gomory-Hu tree.
     /// If \c node is the root of the tree, the result is undefined.
@@ -255,5 +255,5 @@
     ///
     /// This function returns the minimum cut value between the nodes
-    /// \c s and \c t.
+    /// \c s and \c t. 
     /// It finds the nearest common ancestor of the given nodes in the
     /// Gomory-Hu tree and calculates the minimum weight edge on the
@@ -264,13 +264,13 @@
       Node sn = s, tn = t;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) value = (*_weight)[tn];
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) value = (*_weight)[sn];
-          sn = (*_pred)[sn];
-        }
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) value = (*_weight)[tn];
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) value = (*_weight)[sn];
+	  sn = (*_pred)[sn];
+	}
       }
       return value;
@@ -295,7 +295,9 @@
     /// \pre \ref run() must be called before using this function.
     template <typename CutMap>
-    Value minCutMap(const Node& s,
+    Value minCutMap(const Node& s, ///< 
                     const Node& t,
+                    ///< 
                     CutMap& cutMap
+                    ///< 
                     ) const {
       Node sn = s, tn = t;
@@ -303,21 +305,21 @@
       Node rn = INVALID;
       Value value = std::numeric_limits<Value>::max();
-
+      
       while (sn != tn) {
-        if ((*_order)[sn] < (*_order)[tn]) {
-          if ((*_weight)[tn] <= value) {
-            rn = tn;
+	if ((*_order)[sn] < (*_order)[tn]) {
+	  if ((*_weight)[tn] <= value) {
+	    rn = tn;
             s_root = false;
-            value = (*_weight)[tn];
-          }
-          tn = (*_pred)[tn];
-        } else {
-          if ((*_weight)[sn] <= value) {
-            rn = sn;
+	    value = (*_weight)[tn];
+	  }
+	  tn = (*_pred)[tn];
+	} else {
+	  if ((*_weight)[sn] <= value) {
+	    rn = sn;
             s_root = true;
-            value = (*_weight)[sn];
-          }
-          sn = (*_pred)[sn];
-        }
+	    value = (*_weight)[sn];
+	  }
+	  sn = (*_pred)[sn];
+	}
       }
 
@@ -330,16 +332,16 @@
       std::vector<Node> st;
       for (NodeIt n(_graph); n != INVALID; ++n) {
-        st.clear();
+	st.clear();
         Node nn = n;
-        while (!reached[nn]) {
-          st.push_back(nn);
-          nn = (*_pred)[nn];
-        }
-        while (!st.empty()) {
-          cutMap.set(st.back(), cutMap[nn]);
-          st.pop_back();
-        }
-      }
-
+	while (!reached[nn]) {
+	  st.push_back(nn);
+	  nn = (*_pred)[nn];
+	}
+	while (!st.empty()) {
+	  cutMap.set(st.back(), cutMap[nn]);
+	  st.pop_back();
+	}
+      }
+      
       return value;
     }
@@ -350,5 +352,5 @@
 
     /// Iterate on the nodes of a minimum cut
-
+    
     /// This iterator class lists the nodes of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -358,8 +360,8 @@
     /// \c t.
     /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int cnt=0;
-    /// for(GomoryHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
+    /// for(GomoruHu<Graph>::MinCutNodeIt n(gom,s,t); n!=INVALID; ++n) ++cnt;
     /// \endcode
     class MinCutNodeIt
@@ -393,5 +395,5 @@
                    /// \endcode
                    /// does not necessarily give the same set of nodes.
-                   /// However, it is ensured that
+                   /// However it is ensured that
                    /// \code
                    /// MinCutNodeIt(gomory, s, t, true);
@@ -443,9 +445,9 @@
       }
     };
-
+    
     friend class MinCutEdgeIt;
-
+    
     /// Iterate on the edges of a minimum cut
-
+    
     /// This iterator class lists the edges of a minimum cut found by
     /// GomoryHu. Before using it, you must allocate a GomoryHu class
@@ -455,8 +457,8 @@
     /// \c t.
     /// \code
-    /// GomoryHu<Graph> gom(g, capacities);
+    /// GomoruHu<Graph> gom(g, capacities);
     /// gom.run();
     /// int value=0;
-    /// for(GomoryHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
+    /// for(GomoruHu<Graph>::MinCutEdgeIt e(gom,s,t); e!=INVALID; ++e)
     ///   value+=capacities[e];
     /// \endcode
@@ -480,5 +482,5 @@
           }
       }
-
+      
     public:
       /// Constructor
@@ -549,5 +551,5 @@
       }
       /// Postfix incrementation
-
+      
       /// Postfix incrementation.
       ///
Index: lemon/graph_to_eps.h
===================================================================
--- lemon/graph_to_eps.h	(revision 964)
+++ lemon/graph_to_eps.h	(revision 959)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -143,5 +143,5 @@
   ///\param gr  Reference to the graph to be printed.
   ///\param ost Reference to the output stream.
-  ///By default, it is <tt>std::cout</tt>.
+  ///By default it is <tt>std::cout</tt>.
   ///\param pros If it is \c true, then the \c ostream referenced by \c os
   ///will be explicitly deallocated by the destructor.
@@ -513,5 +513,5 @@
   ///Turn on/off pre-scaling
 
-  ///By default, graphToEps() rescales the whole image in order to avoid
+  ///By default graphToEps() rescales the whole image in order to avoid
   ///very big or very small bounding boxes.
   ///
@@ -1115,5 +1115,5 @@
 ///\param g Reference to the graph to be printed.
 ///\param os Reference to the output stream.
-///By default, it is <tt>std::cout</tt>.
+///By default it is <tt>std::cout</tt>.
 ///
 ///This function also has a lot of
@@ -1127,5 +1127,5 @@
 ///\endcode
 ///
-///For more detailed examples, see the \ref graph_to_eps_demo.cc demo file.
+///For more detailed examples see the \ref graph_to_eps_demo.cc demo file.
 ///
 ///\warning Don't forget to put the \ref GraphToEps::run() "run()"
Index: lemon/grid_graph.h
===================================================================
--- lemon/grid_graph.h	(revision 787)
+++ lemon/grid_graph.h	(revision 617)
@@ -471,19 +471,15 @@
   /// \brief Grid graph class
   ///
-  /// GridGraph implements a special graph type. The nodes of the
-  /// graph can be indexed by two integer values \c (i,j) where \c i is
-  /// in the range <tt>[0..width()-1]</tt> and j is in the range
-  /// <tt>[0..height()-1]</tt>. Two nodes are connected in the graph if
-  /// the indices differ exactly on one position and the difference is
-  /// also exactly one. The nodes of the graph can be obtained by position
-  /// using the \c operator()() function and the indices of the nodes can
-  /// be obtained using \c pos(), \c col() and \c row() members. The outgoing
+  /// This class implements a special graph type. The nodes of the
+  /// graph can be indexed by two integer \c (i,j) value where \c i is
+  /// in the \c [0..width()-1] range and j is in the \c
+  /// [0..height()-1] range.  Two nodes are connected in the graph if
+  /// the indexes differ exactly on one position and exactly one is
+  /// the difference. The nodes of the graph can be indexed by position
+  /// with the \c operator()() function. The positions of the nodes can be
+  /// get with \c pos(), \c col() and \c row() members. The outgoing
   /// arcs can be retrieved with the \c right(), \c up(), \c left()
   /// and \c down() functions, where the bottom-left corner is the
   /// origin.
-  ///
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however
-  /// the structure can be resized using resize().
   ///
   /// \image html grid_graph.png
@@ -501,9 +497,6 @@
   ///\endcode
   ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
+  /// This graph type fully conforms to the \ref concepts::Graph
+  /// "Graph concept".
   class GridGraph : public ExtendedGridGraphBase {
     typedef ExtendedGridGraphBase Parent;
@@ -511,9 +504,7 @@
   public:
 
-    /// \brief Map to get the indices of the nodes as \ref dim2::Point
-    /// "dim2::Point<int>".
-    ///
-    /// Map to get the indices of the nodes as \ref dim2::Point
-    /// "dim2::Point<int>".
+    /// \brief Map to get the indices of the nodes as dim2::Point<int>.
+    ///
+    /// Map to get the indices of the nodes as dim2::Point<int>.
     class IndexMap {
     public:
@@ -524,7 +515,11 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       IndexMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.pos(key);
@@ -546,7 +541,11 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       ColMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.col(key);
@@ -568,7 +567,11 @@
 
       /// \brief Constructor
+      ///
+      /// Constructor
       RowMap(const GridGraph& graph) : _graph(graph) {}
 
       /// \brief The subscript operator
+      ///
+      /// The subscript operator.
       Value operator[](Key key) const {
         return _graph.row(key);
@@ -581,12 +584,13 @@
     /// \brief Constructor
     ///
-    /// Construct a grid graph with the given size.
+    /// Construct a grid graph with given size.
     GridGraph(int width, int height) { construct(width, height); }
 
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
+    /// \brief Resize the graph
+    ///
+    /// Resize the graph. The function will fully destroy and rebuild
+    /// the graph.  This cause that the maps of the graph will
+    /// reallocated automatically and the previous values will be
+    /// lost.
     void resize(int width, int height) {
       Parent::notifier(Arc()).clear();
@@ -606,5 +610,5 @@
     }
 
-    /// \brief The column index of the node.
+    /// \brief Gives back the column index of the node.
     ///
     /// Gives back the column index of the node.
@@ -613,5 +617,5 @@
     }
 
-    /// \brief The row index of the node.
+    /// \brief Gives back the row index of the node.
     ///
     /// Gives back the row index of the node.
@@ -620,5 +624,5 @@
     }
 
-    /// \brief The position of the node.
+    /// \brief Gives back the position of the node.
     ///
     /// Gives back the position of the node, ie. the <tt>(col,row)</tt> pair.
@@ -627,5 +631,5 @@
     }
 
-    /// \brief The number of the columns.
+    /// \brief Gives back the number of the columns.
     ///
     /// Gives back the number of the columns.
@@ -634,5 +638,5 @@
     }
 
-    /// \brief The number of the rows.
+    /// \brief Gives back the number of the rows.
     ///
     /// Gives back the number of the rows.
@@ -641,5 +645,5 @@
     }
 
-    /// \brief The arc goes right from the node.
+    /// \brief Gives back the arc goes right from the node.
     ///
     /// Gives back the arc goes right from the node. If there is not
@@ -649,5 +653,5 @@
     }
 
-    /// \brief The arc goes left from the node.
+    /// \brief Gives back the arc goes left from the node.
     ///
     /// Gives back the arc goes left from the node. If there is not
@@ -657,5 +661,5 @@
     }
 
-    /// \brief The arc goes up from the node.
+    /// \brief Gives back the arc goes up from the node.
     ///
     /// Gives back the arc goes up from the node. If there is not
@@ -665,5 +669,5 @@
     }
 
-    /// \brief The arc goes down from the node.
+    /// \brief Gives back the arc goes down from the node.
     ///
     /// Gives back the arc goes down from the node. If there is not
Index: mon/grosso_locatelli_pullan_mc.h
===================================================================
--- lemon/grosso_locatelli_pullan_mc.h	(revision 918)
+++ 	(revision )
@@ -1,840 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_GROSSO_LOCATELLI_PULLAN_MC_H
-#define LEMON_GROSSO_LOCATELLI_PULLAN_MC_H
-
-/// \ingroup approx_algs
-///
-/// \file
-/// \brief The iterated local search algorithm of Grosso, Locatelli, and Pullan
-/// for the maximum clique problem
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/random.h>
-
-namespace lemon {
-
-  /// \addtogroup approx_algs
-  /// @{
-
-  /// \brief Implementation of the iterated local search algorithm of Grosso,
-  /// Locatelli, and Pullan for the maximum clique problem
-  ///
-  /// \ref GrossoLocatelliPullanMc implements the iterated local search
-  /// algorithm of Grosso, Locatelli, and Pullan for solving the \e maximum
-  /// \e clique \e problem \ref grosso08maxclique.
-  /// It is to find the largest complete subgraph (\e clique) in an
-  /// undirected graph, i.e., the largest set of nodes where each
-  /// pair of nodes is connected.
-  ///
-  /// This class provides a simple but highly efficient and robust heuristic
-  /// method that quickly finds a quite large clique, but not necessarily the
-  /// largest one.
-  /// The algorithm performs a certain number of iterations to find several
-  /// cliques and selects the largest one among them. Various limits can be
-  /// specified to control the running time and the effectiveness of the
-  /// search process.
-  ///
-  /// \tparam GR The undirected graph type the algorithm runs on.
-  ///
-  /// \note %GrossoLocatelliPullanMc provides three different node selection
-  /// rules, from which the most powerful one is used by default.
-  /// For more information, see \ref SelectionRule.
-  template <typename GR>
-  class GrossoLocatelliPullanMc
-  {
-  public:
-
-    /// \brief Constants for specifying the node selection rule.
-    ///
-    /// Enum type containing constants for specifying the node selection rule
-    /// for the \ref run() function.
-    ///
-    /// During the algorithm, nodes are selected for addition to the current
-    /// clique according to the applied rule.
-    /// In general, the PENALTY_BASED rule turned out to be the most powerful
-    /// and the most robust, thus it is the default option.
-    /// However, another selection rule can be specified using the \ref run()
-    /// function with the proper parameter.
-    enum SelectionRule {
-
-      /// A node is selected randomly without any evaluation at each step.
-      RANDOM,
-
-      /// A node of maximum degree is selected randomly at each step.
-      DEGREE_BASED,
-
-      /// A node of minimum penalty is selected randomly at each step.
-      /// The node penalties are updated adaptively after each stage of the
-      /// search process.
-      PENALTY_BASED
-    };
-
-    /// \brief Constants for the causes of search termination.
-    ///
-    /// Enum type containing constants for the different causes of search
-    /// termination. The \ref run() function returns one of these values.
-    enum TerminationCause {
-
-      /// The iteration count limit is reached.
-      ITERATION_LIMIT,
-
-      /// The step count limit is reached.
-      STEP_LIMIT,
-
-      /// The clique size limit is reached.
-      SIZE_LIMIT
-    };
-
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(GR);
-
-    typedef std::vector<int> IntVector;
-    typedef std::vector<char> BoolVector;
-    typedef std::vector<BoolVector> BoolMatrix;
-    // Note: vector<char> is used instead of vector<bool> for efficiency reasons
-
-    // The underlying graph
-    const GR &_graph;
-    IntNodeMap _id;
-
-    // Internal matrix representation of the graph
-    BoolMatrix _gr;
-    int _n;
-    
-    // Search options
-    bool _delta_based_restart;
-    int _restart_delta_limit;
- 
-    // Search limits
-    int _iteration_limit;
-    int _step_limit;
-    int _size_limit;
-
-    // The current clique
-    BoolVector _clique;
-    int _size;
-
-    // The best clique found so far
-    BoolVector _best_clique;
-    int _best_size;
-
-    // The "distances" of the nodes from the current clique.
-    // _delta[u] is the number of nodes in the clique that are
-    // not connected with u.
-    IntVector _delta;
-
-    // The current tabu set
-    BoolVector _tabu;
-
-    // Random number generator
-    Random _rnd;
-
-  private:
-
-    // Implementation of the RANDOM node selection rule.
-    class RandomSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-
-    public:
-
-      // Constructor
-      RandomSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n)
-      {}
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i]) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i]) return i;
-        }
-        return -1;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i]) return i;
-        }
-        return -1;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0) return i;
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0) return i;
-        }
-        return -1;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class RandomSelectionRule
-
-
-    // Implementation of the DEGREE_BASED node selection rule.
-    class DegreeBasedSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-      IntVector _deg;
-
-    public:
-
-      // Constructor
-      DegreeBasedSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n), _deg(_n)
-      {
-        for (int i = 0; i != _n; i++) {
-          int d = 0;
-          BoolVector &row = mc._gr[i];
-          for (int j = 0; j != _n; j++) {
-            if (row[j]) d++;
-          }
-          _deg[i] = d;
-        }
-      }
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, max_deg = -1;
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && _deg[i] > max_deg) {
-            node = i;
-            max_deg = _deg[i];
-          }
-        }
-        return node;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class DegreeBasedSelectionRule
-
-
-    // Implementation of the PENALTY_BASED node selection rule.
-    class PenaltyBasedSelectionRule
-    {
-    private:
-
-      // References to the algorithm instance
-      const BoolVector &_clique;
-      const IntVector  &_delta;
-      const BoolVector &_tabu;
-      Random &_rnd;
-
-      // Pivot rule data
-      int _n;
-      IntVector _penalty;
-
-    public:
-
-      // Constructor
-      PenaltyBasedSelectionRule(GrossoLocatelliPullanMc &mc) :
-        _clique(mc._clique), _delta(mc._delta), _tabu(mc._tabu),
-        _rnd(mc._rnd), _n(mc._n), _penalty(_n, 0)
-      {}
-
-      // Return a node index for a feasible add move or -1 if no one exists
-      int nextFeasibleAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && !_tabu[i] && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for a feasible swap move or -1 if no one exists
-      int nextFeasibleSwapNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (!_clique[i] && _delta[i] == 1 && !_tabu[i] &&
-              _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Return a node index for an add move or -1 if no one exists
-      int nextAddNode() const {
-        int start_node = _rnd[_n];
-        int node = -1, min_p = std::numeric_limits<int>::max();
-        for (int i = start_node; i != _n; i++) {
-          if (_delta[i] == 0 && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        for (int i = 0; i != start_node; i++) {
-          if (_delta[i] == 0 && _penalty[i] < min_p) {
-            node = i;
-            min_p = _penalty[i];
-          }
-        }
-        return node;
-      }
-
-      // Update internal data structures between stages (if necessary)
-      void update() {}
-
-    }; //class PenaltyBasedSelectionRule
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// The global \ref rnd "random number generator instance" is used
-    /// during the algorithm.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    GrossoLocatelliPullanMc(const GR& graph) :
-      _graph(graph), _id(_graph), _rnd(rnd)
-    {
-      initOptions();
-    }
-
-    /// \brief Constructor with random seed.
-    ///
-    /// Constructor with random seed.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    /// \param seed Seed value for the internal random number generator
-    /// that is used during the algorithm.
-    GrossoLocatelliPullanMc(const GR& graph, int seed) :
-      _graph(graph), _id(_graph), _rnd(seed)
-    {
-      initOptions();
-    }
-
-    /// \brief Constructor with random number generator.
-    ///
-    /// Constructor with random number generator.
-    ///
-    /// \param graph The undirected graph the algorithm runs on.
-    /// \param random A random number generator that is used during the
-    /// algorithm.
-    GrossoLocatelliPullanMc(const GR& graph, const Random& random) :
-      _graph(graph), _id(_graph), _rnd(random)
-    {
-      initOptions();
-    }
-
-    /// \name Execution Control
-    /// The \ref run() function can be used to execute the algorithm.\n
-    /// The functions \ref iterationLimit(int), \ref stepLimit(int), and 
-    /// \ref sizeLimit(int) can be used to specify various limits for the
-    /// search process.
-    
-    /// @{
-    
-    /// \brief Sets the maximum number of iterations.
-    ///
-    /// This function sets the maximum number of iterations.
-    /// Each iteration of the algorithm finds a maximal clique (but not
-    /// necessarily the largest one) by performing several search steps
-    /// (node selections).
-    ///
-    /// This limit controls the running time and the success of the
-    /// algorithm. For larger values, the algorithm runs slower, but it more
-    /// likely finds larger cliques. For smaller values, the algorithm is
-    /// faster but probably gives worse results.
-    /// 
-    /// The default value is \c 1000.
-    /// \c -1 means that number of iterations is not limited.
-    ///
-    /// \warning You should specify a reasonable limit for the number of
-    /// iterations and/or the number of search steps.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa stepLimit(int)
-    /// \sa sizeLimit(int)
-    GrossoLocatelliPullanMc& iterationLimit(int limit) {
-      _iteration_limit = limit;
-      return *this;
-    }
-    
-    /// \brief Sets the maximum number of search steps.
-    ///
-    /// This function sets the maximum number of elementary search steps.
-    /// Each iteration of the algorithm finds a maximal clique (but not
-    /// necessarily the largest one) by performing several search steps
-    /// (node selections).
-    ///
-    /// This limit controls the running time and the success of the
-    /// algorithm. For larger values, the algorithm runs slower, but it more
-    /// likely finds larger cliques. For smaller values, the algorithm is
-    /// faster but probably gives worse results.
-    /// 
-    /// The default value is \c -1, which means that number of steps
-    /// is not limited explicitly. However, the number of iterations is
-    /// limited and each iteration performs a finite number of search steps.
-    ///
-    /// \warning You should specify a reasonable limit for the number of
-    /// iterations and/or the number of search steps.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa iterationLimit(int)
-    /// \sa sizeLimit(int)
-    GrossoLocatelliPullanMc& stepLimit(int limit) {
-      _step_limit = limit;
-      return *this;
-    }
-    
-    /// \brief Sets the desired clique size.
-    ///
-    /// This function sets the desired clique size that serves as a search
-    /// limit. If a clique of this size (or a larger one) is found, then the
-    /// algorithm terminates.
-    /// 
-    /// This function is especially useful if you know an exact upper bound
-    /// for the size of the cliques in the graph or if any clique above 
-    /// a certain size limit is sufficient for your application.
-    /// 
-    /// The default value is \c -1, which means that the size limit is set to
-    /// the number of nodes in the graph.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \sa iterationLimit(int)
-    /// \sa stepLimit(int)
-    GrossoLocatelliPullanMc& sizeLimit(int limit) {
-      _size_limit = limit;
-      return *this;
-    }
-    
-    /// \brief The maximum number of iterations.
-    ///
-    /// This function gives back the maximum number of iterations.
-    /// \c -1 means that no limit is specified.
-    ///
-    /// \sa iterationLimit(int)
-    int iterationLimit() const {
-      return _iteration_limit;
-    }
-    
-    /// \brief The maximum number of search steps.
-    ///
-    /// This function gives back the maximum number of search steps.
-    /// \c -1 means that no limit is specified.
-    ///
-    /// \sa stepLimit(int)
-    int stepLimit() const {
-      return _step_limit;
-    }
-    
-    /// \brief The desired clique size.
-    ///
-    /// This function gives back the desired clique size that serves as a
-    /// search limit. \c -1 means that this limit is set to the number of
-    /// nodes in the graph.
-    ///
-    /// \sa sizeLimit(int)
-    int sizeLimit() const {
-      return _size_limit;
-    }
-
-    /// \brief Runs the algorithm.
-    ///
-    /// This function runs the algorithm. If one of the specified limits
-    /// is reached, the search process terminates.
-    ///
-    /// \param rule The node selection rule. For more information, see
-    /// \ref SelectionRule.
-    ///
-    /// \return The termination cause of the search. For more information,
-    /// see \ref TerminationCause.
-    TerminationCause run(SelectionRule rule = PENALTY_BASED)
-    {
-      init();
-      switch (rule) {
-        case RANDOM:
-          return start<RandomSelectionRule>();
-        case DEGREE_BASED:
-          return start<DegreeBasedSelectionRule>();
-        default:
-          return start<PenaltyBasedSelectionRule>();
-      }
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these functions.\n
-    /// The run() function must be called before using them. 
-
-    /// @{
-
-    /// \brief The size of the found clique
-    ///
-    /// This function returns the size of the found clique.
-    ///
-    /// \pre run() must be called before using this function.
-    int cliqueSize() const {
-      return _best_size;
-    }
-
-    /// \brief Gives back the found clique in a \c bool node map
-    ///
-    /// This function gives back the characteristic vector of the found
-    /// clique in the given node map.
-    /// It must be a \ref concepts::WriteMap "writable" node map with
-    /// \c bool (or convertible) value type.
-    ///
-    /// \pre run() must be called before using this function.
-    template <typename CliqueMap>
-    void cliqueMap(CliqueMap &map) const {
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        map[n] = static_cast<bool>(_best_clique[_id[n]]);
-      }
-    }
-
-    /// \brief Iterator to list the nodes of the found clique
-    ///
-    /// This iterator class lists the nodes of the found clique.
-    /// Before using it, you must allocate a GrossoLocatelliPullanMc instance
-    /// and call its \ref GrossoLocatelliPullanMc::run() "run()" method.
-    ///
-    /// The following example prints out the IDs of the nodes in the found
-    /// clique.
-    /// \code
-    ///   GrossoLocatelliPullanMc<Graph> mc(g);
-    ///   mc.run();
-    ///   for (GrossoLocatelliPullanMc<Graph>::CliqueNodeIt n(mc);
-    ///        n != INVALID; ++n)
-    ///   {
-    ///     std::cout << g.id(n) << std::endl;
-    ///   }
-    /// \endcode
-    class CliqueNodeIt
-    {
-    private:
-      NodeIt _it;
-      BoolNodeMap _map;
-
-    public:
-
-      /// Constructor
-
-      /// Constructor.
-      /// \param mc The algorithm instance.
-      CliqueNodeIt(const GrossoLocatelliPullanMc &mc)
-       : _map(mc._graph)
-      {
-        mc.cliqueMap(_map);
-        for (_it = NodeIt(mc._graph); _it != INVALID && !_map[_it]; ++_it) ;
-      }
-
-      /// Conversion to \c Node
-      operator Node() const { return _it; }
-
-      bool operator==(Invalid) const { return _it == INVALID; }
-      bool operator!=(Invalid) const { return _it != INVALID; }
-
-      /// Next node
-      CliqueNodeIt &operator++() {
-        for (++_it; _it != INVALID && !_map[_it]; ++_it) ;
-        return *this;
-      }
-
-      /// Postfix incrementation
-
-      /// Postfix incrementation.
-      ///
-      /// \warning This incrementation returns a \c Node, not a
-      /// \c CliqueNodeIt as one may expect.
-      typename GR::Node operator++(int) {
-        Node n=*this;
-        ++(*this);
-        return n;
-      }
-
-    };
-
-    /// @}
-
-  private:
-  
-    // Initialize search options and limits
-    void initOptions() {
-      // Search options
-      _delta_based_restart = true;
-      _restart_delta_limit = 4;
-     
-      // Search limits
-      _iteration_limit = 1000;
-      _step_limit = -1;             // this is disabled by default
-      _size_limit = -1;             // this is disabled by default
-    }
-
-    // Adds a node to the current clique
-    void addCliqueNode(int u) {
-      if (_clique[u]) return;
-      _clique[u] = true;
-      _size++;
-      BoolVector &row = _gr[u];
-      for (int i = 0; i != _n; i++) {
-        if (!row[i]) _delta[i]++;
-      }
-    }
-
-    // Removes a node from the current clique
-    void delCliqueNode(int u) {
-      if (!_clique[u]) return;
-      _clique[u] = false;
-      _size--;
-      BoolVector &row = _gr[u];
-      for (int i = 0; i != _n; i++) {
-        if (!row[i]) _delta[i]--;
-      }
-    }
-
-    // Initialize data structures
-    void init() {
-      _n = countNodes(_graph);
-      int ui = 0;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        _id[u] = ui++;
-      }
-      _gr.clear();
-      _gr.resize(_n, BoolVector(_n, false));
-      ui = 0;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        for (IncEdgeIt e(_graph, u); e != INVALID; ++e) {
-          int vi = _id[_graph.runningNode(e)];
-          _gr[ui][vi] = true;
-          _gr[vi][ui] = true;
-        }
-        ++ui;
-      }
-
-      _clique.clear();
-      _clique.resize(_n, false);
-      _size = 0;
-      _best_clique.clear();
-      _best_clique.resize(_n, false);
-      _best_size = 0;
-      _delta.clear();
-      _delta.resize(_n, 0);
-      _tabu.clear();
-      _tabu.resize(_n, false);
-    }
-
-    // Executes the algorithm
-    template <typename SelectionRuleImpl>
-    TerminationCause start() {
-      if (_n == 0) return SIZE_LIMIT;
-      if (_n == 1) {
-        _best_clique[0] = true;
-        _best_size = 1;
-        return SIZE_LIMIT;
-      }
-
-      // Iterated local search algorithm
-      const int max_size = _size_limit >= 0 ? _size_limit : _n;
-      const int max_restart = _iteration_limit >= 0 ?
-        _iteration_limit : std::numeric_limits<int>::max();
-      const int max_select = _step_limit >= 0 ?
-        _step_limit : std::numeric_limits<int>::max();
-
-      SelectionRuleImpl sel_method(*this);
-      int select = 0, restart = 0;
-      IntVector restart_nodes;
-      while (select < max_select && restart < max_restart) {
-
-        // Perturbation/restart
-        restart++;
-        if (_delta_based_restart) {
-          restart_nodes.clear();
-          for (int i = 0; i != _n; i++) {
-            if (_delta[i] >= _restart_delta_limit)
-              restart_nodes.push_back(i);
-          }
-        }
-        int rs_node = -1;
-        if (restart_nodes.size() > 0) {
-          rs_node = restart_nodes[_rnd[restart_nodes.size()]];
-        } else {
-          rs_node = _rnd[_n];
-        }
-        BoolVector &row = _gr[rs_node];
-        for (int i = 0; i != _n; i++) {
-          if (_clique[i] && !row[i]) delCliqueNode(i);
-        }
-        addCliqueNode(rs_node);
-
-        // Local search
-        _tabu.clear();
-        _tabu.resize(_n, false);
-        bool tabu_empty = true;
-        int max_swap = _size;
-        while (select < max_select) {
-          select++;
-          int u;
-          if ((u = sel_method.nextFeasibleAddNode()) != -1) {
-            // Feasible add move
-            addCliqueNode(u);
-            if (tabu_empty) max_swap = _size;
-          }
-          else if ((u = sel_method.nextFeasibleSwapNode()) != -1) {
-            // Feasible swap move
-            int v = -1;
-            BoolVector &row = _gr[u];
-            for (int i = 0; i != _n; i++) {
-              if (_clique[i] && !row[i]) {
-                v = i;
-                break;
-              }
-            }
-            addCliqueNode(u);
-            delCliqueNode(v);
-            _tabu[v] = true;
-            tabu_empty = false;
-            if (--max_swap <= 0) break;
-          }
-          else if ((u = sel_method.nextAddNode()) != -1) {
-            // Non-feasible add move
-            addCliqueNode(u);
-          }
-          else break;
-        }
-        if (_size > _best_size) {
-          _best_clique = _clique;
-          _best_size = _size;
-          if (_best_size >= max_size) return SIZE_LIMIT;
-        }
-        sel_method.update();
-      }
-
-      return (restart >= max_restart ? ITERATION_LIMIT : STEP_LIMIT);
-    }
-
-  }; //class GrossoLocatelliPullanMc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_GROSSO_LOCATELLI_PULLAN_MC_H
Index: lemon/hao_orlin.h
===================================================================
--- lemon/hao_orlin.h	(revision 915)
+++ lemon/hao_orlin.h	(revision 597)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -32,5 +32,5 @@
 /// \brief Implementation of the Hao-Orlin algorithm.
 ///
-/// Implementation of the Hao-Orlin algorithm for finding a minimum cut
+/// Implementation of the Hao-Orlin algorithm for finding a minimum cut 
 /// in a digraph.
 
@@ -42,5 +42,5 @@
   ///
   /// This class implements the Hao-Orlin algorithm for finding a minimum
-  /// value cut in a directed graph \f$D=(V,A)\f$.
+  /// value cut in a directed graph \f$D=(V,A)\f$. 
   /// It takes a fixed node \f$ source \in V \f$ and
   /// consists of two phases: in the first phase it determines a
@@ -54,10 +54,10 @@
   /// preflow push-relabel algorithm. Our implementation calculates
   /// the minimum cut in \f$ O(n^2\sqrt{m}) \f$ time (we use the
-  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. A notable
-  /// use of this algorithm is testing network reliability.
+  /// highest-label rule), or in \f$O(nm)\f$ for unit capacities. The
+  /// purpose of such algorithm is e.g. testing network reliability.
   ///
   /// For an undirected graph you can run just the first phase of the
   /// algorithm or you can use the algorithm of Nagamochi and Ibaraki,
-  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$
+  /// which solves the undirected problem in \f$ O(nm + n^2 \log n) \f$ 
   /// time. It is implemented in the NagamochiIbaraki algorithm class.
   ///
@@ -77,5 +77,5 @@
   class HaoOrlin {
   public:
-
+   
     /// The digraph type of the algorithm
     typedef GR Digraph;
@@ -164,21 +164,4 @@
         delete _flow;
       }
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
-    HaoOrlin& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
     }
 
@@ -865,5 +848,5 @@
     ///
     /// This function initializes the internal data structures. It creates
-    /// the maps and some bucket structures for the algorithm.
+    /// the maps and some bucket structures for the algorithm. 
     /// The given node is used as the source node for the push-relabel
     /// algorithm.
@@ -913,6 +896,4 @@
     /// source-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \in X \f$ and minimal outgoing capacity).
-    /// It updates the stored cut if (and only if) the newly found one
-    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
@@ -927,6 +908,4 @@
     /// sink-side (i.e. a set \f$ X\subsetneq V \f$ with
     /// \f$ source \notin X \f$ and minimal outgoing capacity).
-    /// It updates the stored cut if (and only if) the newly found one
-    /// is better.
     ///
     /// \pre \ref init() must be called before using this function.
@@ -938,6 +917,6 @@
     /// \brief Run the algorithm.
     ///
-    /// This function runs the algorithm. It chooses source node,
-    /// then calls \ref init(), \ref calculateOut()
+    /// This function runs the algorithm. It finds nodes \c source and
+    /// \c target arbitrarily and then calls \ref init(), \ref calculateOut()
     /// and \ref calculateIn().
     void run() {
@@ -949,7 +928,7 @@
     /// \brief Run the algorithm.
     ///
-    /// This function runs the algorithm. It calls \ref init(),
-    /// \ref calculateOut() and \ref calculateIn() with the given
-    /// source node.
+    /// This function runs the algorithm. It uses the given \c source node, 
+    /// finds a proper \c target node and then calls the \ref init(),
+    /// \ref calculateOut() and \ref calculateIn().
     void run(const Node& s) {
       init(s);
@@ -963,5 +942,5 @@
     /// The result of the %HaoOrlin algorithm
     /// can be obtained using these functions.\n
-    /// \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// should be called before using them.
 
@@ -970,9 +949,7 @@
     /// \brief Return the value of the minimum cut.
     ///
-    /// This function returns the value of the best cut found by the
-    /// previously called \ref run(), \ref calculateOut() or \ref
-    /// calculateIn().
-    ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// This function returns the value of the minimum cut.
+    ///
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     Value minCutValue() const {
@@ -983,11 +960,7 @@
     /// \brief Return a minimum cut.
     ///
-    /// This function gives the best cut found by the
-    /// previously called \ref run(), \ref calculateOut() or \ref
-    /// calculateIn().
-    ///
-    /// It sets \c cutMap to the characteristic vector of the found
-    /// minimum value cut - a non-empty set \f$ X\subsetneq V \f$
-    /// of minimum outgoing capacity (i.e. \c cutMap will be \c true exactly
+    /// This function sets \c cutMap to the characteristic vector of a
+    /// minimum value cut: it will give a non-empty set \f$ X\subsetneq V \f$
+    /// with minimal outgoing capacity (i.e. \c cutMap will be \c true exactly
     /// for the nodes of \f$ X \f$).
     ///
@@ -997,5 +970,5 @@
     /// \return The value of the minimum cut.
     ///
-    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn()
+    /// \pre \ref run(), \ref calculateOut() or \ref calculateIn() 
     /// must be called before using this function.
     template <typename CutMap>
Index: mon/hartmann_orlin_mmc.h
===================================================================
--- lemon/hartmann_orlin_mmc.h	(revision 879)
+++ 	(revision )
@@ -1,650 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_HARTMANN_ORLIN_MMC_H
-#define LEMON_HARTMANN_ORLIN_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Hartmann-Orlin's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of HartmannOrlinMmc class.
-  ///
-  /// Default traits class of HartmannOrlinMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct HartmannOrlinMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct HartmannOrlinMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of the Hartmann-Orlin algorithm for finding
-  /// a minimum mean cycle.
-  ///
-  /// This class implements the Hartmann-Orlin algorithm for finding
-  /// a directed cycle of minimum mean cost in a digraph
-  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
-  /// It is an improved version of \ref KarpMmc "Karp"'s original algorithm,
-  /// it applies an efficient early termination scheme.
-  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref HartmannOrlinMmcDefaultTraits
-  /// "HartmannOrlinMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = HartmannOrlinMmcDefaultTraits<GR, CM> >
-#endif
-  class HartmannOrlinMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref HartmannOrlinMmcDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref HartmannOrlinMmcDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeCost dist;
-      Arc pred;
-      PathData(LargeCost d, Arc p = INVALID) :
-        dist(d), pred(p) {}
-    };
-
-    typedef typename Digraph::template NodeMap<std::vector<PathData> >
-      PathDataNodeMap;
-
-  private:
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
-
-    // Data for the found cycles
-    bool _curr_found, _best_found;
-    LargeCost _curr_cost, _best_cost;
-    int _curr_size, _best_size;
-    Node _curr_node, _best_node;
-    int _curr_level, _best_level;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Node map for storing path data
-    PathDataNodeMap _data;
-    // The processed nodes in the last round
-    std::vector<Node> _process;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public HartmannOrlinMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef HartmannOrlinMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    template <typename T>
-    struct SetPath
-      : public HartmannOrlinMmc<GR, CM, SetPathTraits<T> > {
-      typedef HartmannOrlinMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    HartmannOrlinMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    HartmannOrlinMmc( const Digraph &digraph,
-                      const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph),
-      _best_found(false), _best_cost(0), _best_size(1),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~HartmannOrlinMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), it will allocate a local \ref Path "path"
-    /// structure. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addFront()
-    /// "addFront()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    HartmannOrlinMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    HartmannOrlinMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findCycleMean() {
-      // Initialization and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        if (!initComponent(comp)) continue;
-        processRounds();
-
-        // Update the best cycle (global minimum mean cycle)
-        if ( _curr_found && (!_best_found ||
-             _curr_cost * _best_size < _best_cost * _curr_size) ) {
-          _best_found = true;
-          _best_cost = _curr_cost;
-          _best_size = _curr_size;
-          _best_node = _curr_node;
-          _best_level = _curr_level;
-        }
-      }
-      return _best_found;
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (!_best_found) return false;
-      IntNodeMap reached(_gr, -1);
-      int r = _best_level + 1;
-      Node u = _best_node;
-      while (reached[u] < 0) {
-        reached[u] = --r;
-        u = _gr.source(_data[u][r].pred);
-      }
-      r = reached[u];
-      Arc e = _data[u][r].pred;
-      _cycle_path->addFront(e);
-      _best_cost = _cost[e];
-      _best_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _best_cost += _cost[e];
-        ++_best_size;
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_best_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_cost) / _best_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialization
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _cycle_path->clear();
-      _best_found = false;
-      _best_cost = 0;
-      _best_size = 1;
-      _cycle_path->clear();
-      for (NodeIt u(_gr); u != INVALID; ++u)
-        _data[u].clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _out_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            _out_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Initialize path data for the current component
-    bool initComponent(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      int n = _nodes->size();
-      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < n; ++i) {
-        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
-      }
-      return true;
-    }
-
-    // Process all rounds of computing path data for the current component.
-    // _data[v][k] is the cost of a shortest directed walk from the root
-    // node to node v containing exactly k arcs.
-    void processRounds() {
-      Node start = (*_nodes)[0];
-      _data[start][0] = PathData(0);
-      _process.clear();
-      _process.push_back(start);
-
-      int k, n = _nodes->size();
-      int next_check = 4;
-      bool terminate = false;
-      for (k = 1; k <= n && int(_process.size()) < n && !terminate; ++k) {
-        processNextBuildRound(k);
-        if (k == next_check || k == n) {
-          terminate = checkTermination(k);
-          next_check = next_check * 3 / 2;
-        }
-      }
-      for ( ; k <= n && !terminate; ++k) {
-        processNextFullRound(k);
-        if (k == next_check || k == n) {
-          terminate = checkTermination(k);
-          next_check = next_check * 3 / 2;
-        }
-      }
-    }
-
-    // Process one round and rebuild _process
-    void processNextBuildRound(int k) {
-      std::vector<Node> next;
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        u = _process[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            if (_data[v][k].dist == INF) next.push_back(v);
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-      _process.swap(next);
-    }
-
-    // Process one round using _nodes instead of _process
-    void processNextFullRound(int k) {
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-    }
-
-    // Check early termination
-    bool checkTermination(int k) {
-      typedef std::pair<int, int> Pair;
-      typename GR::template NodeMap<Pair> level(_gr, Pair(-1, 0));
-      typename GR::template NodeMap<LargeCost> pi(_gr);
-      int n = _nodes->size();
-      LargeCost cost;
-      int size;
-      Node u;
-
-      // Search for cycles that are already found
-      _curr_found = false;
-      for (int i = 0; i < n; ++i) {
-        u = (*_nodes)[i];
-        if (_data[u][k].dist == INF) continue;
-        for (int j = k; j >= 0; --j) {
-          if (level[u].first == i && level[u].second > 0) {
-            // A cycle is found
-            cost = _data[u][level[u].second].dist - _data[u][j].dist;
-            size = level[u].second - j;
-            if (!_curr_found || cost * _curr_size < _curr_cost * size) {
-              _curr_cost = cost;
-              _curr_size = size;
-              _curr_node = u;
-              _curr_level = level[u].second;
-              _curr_found = true;
-            }
-          }
-          level[u] = Pair(i, j);
-          if (j != 0) {
-            u = _gr.source(_data[u][j].pred);
-          }
-        }
-      }
-
-      // If at least one cycle is found, check the optimality condition
-      LargeCost d;
-      if (_curr_found && k < n) {
-        // Find node potentials
-        for (int i = 0; i < n; ++i) {
-          u = (*_nodes)[i];
-          pi[u] = INF;
-          for (int j = 0; j <= k; ++j) {
-            if (_data[u][j].dist < INF) {
-              d = _data[u][j].dist * _curr_size - j * _curr_cost;
-              if (_tolerance.less(d, pi[u])) pi[u] = d;
-            }
-          }
-        }
-
-        // Check the optimality condition for all arcs
-        bool done = true;
-        for (ArcIt a(_gr); a != INVALID; ++a) {
-          if (_tolerance.less(_cost[a] * _curr_size - _curr_cost,
-                              pi[_gr.target(a)] - pi[_gr.source(a)]) ) {
-            done = false;
-            break;
-          }
-        }
-        return done;
-      }
-      return (k == n);
-    }
-
-  }; //class HartmannOrlinMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HARTMANN_ORLIN_MMC_H
Index: mon/howard_mmc.h
===================================================================
--- lemon/howard_mmc.h	(revision 877)
+++ 	(revision )
@@ -1,605 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_HOWARD_MMC_H
-#define LEMON_HOWARD_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Howard's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of HowardMmc class.
-  ///
-  /// Default traits class of HowardMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct HowardMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct HowardMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of Howard's algorithm for finding a minimum
-  /// mean cycle.
-  ///
-  /// This class implements Howard's policy iteration algorithm for finding
-  /// a directed cycle of minimum mean cost in a digraph
-  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
-  /// This class provides the most efficient algorithm for the
-  /// minimum mean cycle problem, though the best known theoretical
-  /// bound on its running time is exponential.
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref HowardMmcDefaultTraits
-  /// "HowardMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = HowardMmcDefaultTraits<GR, CM> >
-#endif
-  class HowardMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref HowardMmcDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref HowardMmcDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for the found cycles
-    bool _curr_found, _best_found;
-    LargeCost _curr_cost, _best_cost;
-    int _curr_size, _best_size;
-    Node _curr_node, _best_node;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Internal data used by the algorithm
-    typename Digraph::template NodeMap<Arc> _policy;
-    typename Digraph::template NodeMap<bool> _reached;
-    typename Digraph::template NodeMap<int> _level;
-    typename Digraph::template NodeMap<LargeCost> _dist;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _in_arcs;
-
-    // Queue used for BFS search
-    std::vector<Node> _queue;
-    int _qfront, _qback;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public HowardMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef HowardMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    template <typename T>
-    struct SetPath
-      : public HowardMmc<GR, CM, SetPathTraits<T> > {
-      typedef HowardMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    HowardMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    HowardMmc( const Digraph &digraph,
-               const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _best_found(false),
-      _best_cost(0), _best_size(1), _cycle_path(NULL), _local_path(false),
-      _policy(digraph), _reached(digraph), _level(digraph), _dist(digraph),
-      _comp(digraph), _in_arcs(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~HowardMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), it will allocate a local \ref Path "path"
-    /// structure. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addBack()
-    /// "addBack()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    HowardMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    HowardMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findCycleMean() {
-      // Initialize and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        // Find the minimum mean cycle in the current component
-        if (!buildPolicyGraph(comp)) continue;
-        while (true) {
-          findPolicyCycle();
-          if (!computeNodeDistances()) break;
-        }
-        // Update the best cycle (global minimum mean cycle)
-        if ( _curr_found && (!_best_found ||
-             _curr_cost * _best_size < _best_cost * _curr_size) ) {
-          _best_found = true;
-          _best_cost = _curr_cost;
-          _best_size = _curr_size;
-          _best_node = _curr_node;
-        }
-      }
-      return _best_found;
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (!_best_found) return false;
-      _cycle_path->addBack(_policy[_best_node]);
-      for ( Node v = _best_node;
-            (v = _gr.target(_policy[v])) != _best_node; ) {
-        _cycle_path->addBack(_policy[v]);
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_best_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _best_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_best_cost) / _best_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialize
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _queue.resize(countNodes(_gr));
-      _best_found = false;
-      _best_cost = 0;
-      _best_size = 1;
-      _cycle_path->clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _in_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _in_arcs[n].clear();
-          for (InArcIt a(_gr, n); a != INVALID; ++a) {
-            _in_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _in_arcs[n].clear();
-          for (InArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.source(a)] == k) _in_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Build the policy graph in the given strongly connected component
-    // (the out-degree of every node is 1)
-    bool buildPolicyGraph(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      if (_nodes->size() < 1 ||
-          (_nodes->size() == 1 && _in_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _dist[(*_nodes)[i]] = INF;
-      }
-      Node u, v;
-      Arc e;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        v = (*_nodes)[i];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (_cost[e] < _dist[u]) {
-            _dist[u] = _cost[e];
-            _policy[u] = e;
-          }
-        }
-      }
-      return true;
-    }
-
-    // Find the minimum mean cycle in the policy graph
-    void findPolicyCycle() {
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _level[(*_nodes)[i]] = -1;
-      }
-      LargeCost ccost;
-      int csize;
-      Node u, v;
-      _curr_found = false;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        if (_level[u] >= 0) continue;
-        for (; _level[u] < 0; u = _gr.target(_policy[u])) {
-          _level[u] = i;
-        }
-        if (_level[u] == i) {
-          // A cycle is found
-          ccost = _cost[_policy[u]];
-          csize = 1;
-          for (v = u; (v = _gr.target(_policy[v])) != u; ) {
-            ccost += _cost[_policy[v]];
-            ++csize;
-          }
-          if ( !_curr_found ||
-               (ccost * _curr_size < _curr_cost * csize) ) {
-            _curr_found = true;
-            _curr_cost = ccost;
-            _curr_size = csize;
-            _curr_node = u;
-          }
-        }
-      }
-    }
-
-    // Contract the policy graph and compute node distances
-    bool computeNodeDistances() {
-      // Find the component of the main cycle and compute node distances
-      // using reverse BFS
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        _reached[(*_nodes)[i]] = false;
-      }
-      _qfront = _qback = 0;
-      _queue[0] = _curr_node;
-      _reached[_curr_node] = true;
-      _dist[_curr_node] = 0;
-      Node u, v;
-      Arc e;
-      while (_qfront <= _qback) {
-        v = _queue[_qfront++];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (_policy[u] == e && !_reached[u]) {
-            _reached[u] = true;
-            _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-            _queue[++_qback] = u;
-          }
-        }
-      }
-
-      // Connect all other nodes to this component and compute node
-      // distances using reverse BFS
-      _qfront = 0;
-      while (_qback < int(_nodes->size())-1) {
-        v = _queue[_qfront++];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          if (!_reached[u]) {
-            _reached[u] = true;
-            _policy[u] = e;
-            _dist[u] = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-            _queue[++_qback] = u;
-          }
-        }
-      }
-
-      // Improve node distances
-      bool improved = false;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        v = (*_nodes)[i];
-        for (int j = 0; j < int(_in_arcs[v].size()); ++j) {
-          e = _in_arcs[v][j];
-          u = _gr.source(e);
-          LargeCost delta = _dist[v] + _cost[e] * _curr_size - _curr_cost;
-          if (_tolerance.less(delta, _dist[u])) {
-            _dist[u] = delta;
-            _policy[u] = e;
-            improved = true;
-          }
-        }
-      }
-      return improved;
-    }
-
-  }; //class HowardMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_HOWARD_MMC_H
Index: lemon/hypercube_graph.h
===================================================================
--- lemon/hypercube_graph.h	(revision 788)
+++ lemon/hypercube_graph.h	(revision 617)
@@ -263,5 +263,5 @@
     }
 
-    static int index(Node node) {
+    int index(Node node) const {
       return node._id;
     }
@@ -283,21 +283,15 @@
   /// \brief Hypercube graph class
   ///
-  /// HypercubeGraph implements a special graph type. The nodes of the
-  /// graph are indexed with integers having at most \c dim binary digits.
+  /// This class implements a special graph type. The nodes of the graph
+  /// are indiced with integers with at most \c dim binary digits.
   /// Two nodes are connected in the graph if and only if their indices
   /// differ only on one position in the binary form.
-  /// This class is completely static and it needs constant memory space.
-  /// Thus you can neither add nor delete nodes or edges, however,
-  /// the structure can be resized using resize().
-  ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
   ///
   /// \note The type of the indices is chosen to \c int for efficiency
   /// reasons. Thus the maximum dimension of this implementation is 26
   /// (assuming that the size of \c int is 32 bit).
+  ///
+  /// This graph type fully conforms to the \ref concepts::Graph
+  /// "Graph concept".
   class HypercubeGraph : public ExtendedHypercubeGraphBase {
     typedef ExtendedHypercubeGraphBase Parent;
@@ -309,19 +303,4 @@
     /// Constructs a hypercube graph with \c dim dimensions.
     HypercubeGraph(int dim) { construct(dim); }
-
-    /// \brief Resizes the graph
-    ///
-    /// This function resizes the graph. It fully destroys and
-    /// rebuilds the structure, therefore the maps of the graph will be
-    /// reallocated automatically and the previous values will be lost.
-    void resize(int dim) {
-      Parent::notifier(Arc()).clear();
-      Parent::notifier(Edge()).clear();
-      Parent::notifier(Node()).clear();
-      construct(dim);
-      Parent::notifier(Node()).build();
-      Parent::notifier(Edge()).build();
-      Parent::notifier(Arc()).build();
-    }
 
     /// \brief The number of dimensions.
@@ -342,5 +321,5 @@
     ///
     /// Gives back the dimension id of the given edge.
-    /// It is in the range <tt>[0..dim-1]</tt>.
+    /// It is in the [0..dim-1] range.
     int dimension(Edge edge) const {
       return Parent::dimension(edge);
@@ -350,5 +329,5 @@
     ///
     /// Gives back the dimension id of the given arc.
-    /// It is in the range <tt>[0..dim-1]</tt>.
+    /// It is in the [0..dim-1] range.
     int dimension(Arc arc) const {
       return Parent::dimension(arc);
@@ -359,5 +338,5 @@
     /// Gives back the index of the given node.
     /// The lower bits of the integer describes the node.
-    static int index(Node node) {
+    int index(Node node) const {
       return Parent::index(node);
     }
Index: mon/karp_mmc.h
===================================================================
--- lemon/karp_mmc.h	(revision 877)
+++ 	(revision )
@@ -1,590 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_KARP_MMC_H
-#define LEMON_KARP_MMC_H
-
-/// \ingroup min_mean_cycle
-///
-/// \file
-/// \brief Karp's algorithm for finding a minimum mean cycle.
-
-#include <vector>
-#include <limits>
-#include <lemon/core.h>
-#include <lemon/path.h>
-#include <lemon/tolerance.h>
-#include <lemon/connectivity.h>
-
-namespace lemon {
-
-  /// \brief Default traits class of KarpMmc class.
-  ///
-  /// Default traits class of KarpMmc class.
-  /// \tparam GR The type of the digraph.
-  /// \tparam CM The type of the cost map.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-#ifdef DOXYGEN
-  template <typename GR, typename CM>
-#else
-  template <typename GR, typename CM,
-    bool integer = std::numeric_limits<typename CM::Value>::is_integer>
-#endif
-  struct KarpMmcDefaultTraits
-  {
-    /// The type of the digraph
-    typedef GR Digraph;
-    /// The type of the cost map
-    typedef CM CostMap;
-    /// The type of the arc costs
-    typedef typename CostMap::Value Cost;
-
-    /// \brief The large cost type used for internal computations
-    ///
-    /// The large cost type used for internal computations.
-    /// It is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    /// \c Cost must be convertible to \c LargeCost.
-    typedef double LargeCost;
-
-    /// The tolerance type used for internal computations
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    typedef lemon::Path<Digraph> Path;
-  };
-
-  // Default traits class for integer cost types
-  template <typename GR, typename CM>
-  struct KarpMmcDefaultTraits<GR, CM, true>
-  {
-    typedef GR Digraph;
-    typedef CM CostMap;
-    typedef typename CostMap::Value Cost;
-#ifdef LEMON_HAVE_LONG_LONG
-    typedef long long LargeCost;
-#else
-    typedef long LargeCost;
-#endif
-    typedef lemon::Tolerance<LargeCost> Tolerance;
-    typedef lemon::Path<Digraph> Path;
-  };
-
-
-  /// \addtogroup min_mean_cycle
-  /// @{
-
-  /// \brief Implementation of Karp's algorithm for finding a minimum
-  /// mean cycle.
-  ///
-  /// This class implements Karp's algorithm for finding a directed
-  /// cycle of minimum mean cost in a digraph
-  /// \ref amo93networkflows, \ref dasdan98minmeancycle.
-  /// It runs in time O(ne) and uses space O(n<sup>2</sup>+e).
-  ///
-  /// \tparam GR The type of the digraph the algorithm runs on.
-  /// \tparam CM The type of the cost map. The default
-  /// map type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref KarpMmcDefaultTraits
-  /// "KarpMmcDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template < typename GR,
-             typename CM = typename GR::template ArcMap<int>,
-             typename TR = KarpMmcDefaultTraits<GR, CM> >
-#endif
-  class KarpMmc
-  {
-  public:
-
-    /// The type of the digraph
-    typedef typename TR::Digraph Digraph;
-    /// The type of the cost map
-    typedef typename TR::CostMap CostMap;
-    /// The type of the arc costs
-    typedef typename TR::Cost Cost;
-
-    /// \brief The large cost type
-    ///
-    /// The large cost type used for internal computations.
-    /// By default, it is \c long \c long if the \c Cost type is integer,
-    /// otherwise it is \c double.
-    typedef typename TR::LargeCost LargeCost;
-
-    /// The tolerance type
-    typedef typename TR::Tolerance Tolerance;
-
-    /// \brief The path type of the found cycles
-    ///
-    /// The path type of the found cycles.
-    /// Using the \ref KarpMmcDefaultTraits "default traits class",
-    /// it is \ref lemon::Path "Path<Digraph>".
-    typedef typename TR::Path Path;
-
-    /// The \ref KarpMmcDefaultTraits "traits class" of the algorithm
-    typedef TR Traits;
-
-  private:
-
-    TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-
-    // Data sturcture for path data
-    struct PathData
-    {
-      LargeCost dist;
-      Arc pred;
-      PathData(LargeCost d, Arc p = INVALID) :
-        dist(d), pred(p) {}
-    };
-
-    typedef typename Digraph::template NodeMap<std::vector<PathData> >
-      PathDataNodeMap;
-
-  private:
-
-    // The digraph the algorithm runs on
-    const Digraph &_gr;
-    // The cost of the arcs
-    const CostMap &_cost;
-
-    // Data for storing the strongly connected components
-    int _comp_num;
-    typename Digraph::template NodeMap<int> _comp;
-    std::vector<std::vector<Node> > _comp_nodes;
-    std::vector<Node>* _nodes;
-    typename Digraph::template NodeMap<std::vector<Arc> > _out_arcs;
-
-    // Data for the found cycle
-    LargeCost _cycle_cost;
-    int _cycle_size;
-    Node _cycle_node;
-
-    Path *_cycle_path;
-    bool _local_path;
-
-    // Node map for storing path data
-    PathDataNodeMap _data;
-    // The processed nodes in the last round
-    std::vector<Node> _process;
-
-    Tolerance _tolerance;
-
-    // Infinite constant
-    const LargeCost INF;
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetLargeCostTraits : public Traits {
-      typedef T LargeCost;
-      typedef lemon::Tolerance<T> Tolerance;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c LargeCost type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c LargeCost
-    /// type. It is used for internal computations in the algorithm.
-    template <typename T>
-    struct SetLargeCost
-      : public KarpMmc<GR, CM, SetLargeCostTraits<T> > {
-      typedef KarpMmc<GR, CM, SetLargeCostTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting the \c %Path
-    /// type of the found cycles.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addFront() function.
-    template <typename T>
-    struct SetPath
-      : public KarpMmc<GR, CM, SetPathTraits<T> > {
-      typedef KarpMmc<GR, CM, SetPathTraits<T> > Create;
-    };
-
-    /// @}
-
-  protected:
-
-    KarpMmc() {}
-
-  public:
-
-    /// \brief Constructor.
-    ///
-    /// The constructor of the class.
-    ///
-    /// \param digraph The digraph the algorithm runs on.
-    /// \param cost The costs of the arcs.
-    KarpMmc( const Digraph &digraph,
-             const CostMap &cost ) :
-      _gr(digraph), _cost(cost), _comp(digraph), _out_arcs(digraph),
-      _cycle_cost(0), _cycle_size(1), _cycle_node(INVALID),
-      _cycle_path(NULL), _local_path(false), _data(digraph),
-      INF(std::numeric_limits<LargeCost>::has_infinity ?
-          std::numeric_limits<LargeCost>::infinity() :
-          std::numeric_limits<LargeCost>::max())
-    {}
-
-    /// Destructor.
-    ~KarpMmc() {
-      if (_local_path) delete _cycle_path;
-    }
-
-    /// \brief Set the path structure for storing the found cycle.
-    ///
-    /// This function sets an external path structure for storing the
-    /// found cycle.
-    ///
-    /// If you don't call this function before calling \ref run() or
-    /// \ref findCycleMean(), it will allocate a local \ref Path "path"
-    /// structure. The destuctor deallocates this automatically
-    /// allocated object, of course.
-    ///
-    /// \note The algorithm calls only the \ref lemon::Path::addFront()
-    /// "addFront()" function of the given path structure.
-    ///
-    /// \return <tt>(*this)</tt>
-    KarpMmc& cycle(Path &path) {
-      if (_local_path) {
-        delete _cycle_path;
-        _local_path = false;
-      }
-      _cycle_path = &path;
-      return *this;
-    }
-
-    /// \brief Set the tolerance used by the algorithm.
-    ///
-    /// This function sets the tolerance object used by the algorithm.
-    ///
-    /// \return <tt>(*this)</tt>
-    KarpMmc& tolerance(const Tolerance& tolerance) {
-      _tolerance = tolerance;
-      return *this;
-    }
-
-    /// \brief Return a const reference to the tolerance.
-    ///
-    /// This function returns a const reference to the tolerance object
-    /// used by the algorithm.
-    const Tolerance& tolerance() const {
-      return _tolerance;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to call the \ref run()
-    /// function.\n
-    /// If you only need the minimum mean cost, you may call
-    /// \ref findCycleMean().
-
-    /// @{
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// It can be called more than once (e.g. if the underlying digraph
-    /// and/or the arc costs have been modified).
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \note <tt>mmc.run()</tt> is just a shortcut of the following code.
-    /// \code
-    ///   return mmc.findCycleMean() && mmc.findCycle();
-    /// \endcode
-    bool run() {
-      return findCycleMean() && findCycle();
-    }
-
-    /// \brief Find the minimum cycle mean.
-    ///
-    /// This function finds the minimum mean cost of the directed
-    /// cycles in the digraph.
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    bool findCycleMean() {
-      // Initialization and find strongly connected components
-      init();
-      findComponents();
-
-      // Find the minimum cycle mean in the components
-      for (int comp = 0; comp < _comp_num; ++comp) {
-        if (!initComponent(comp)) continue;
-        processRounds();
-        updateMinMean();
-      }
-      return (_cycle_node != INVALID);
-    }
-
-    /// \brief Find a minimum mean directed cycle.
-    ///
-    /// This function finds a directed cycle of minimum mean cost
-    /// in the digraph using the data computed by findCycleMean().
-    ///
-    /// \return \c true if a directed cycle exists in the digraph.
-    ///
-    /// \pre \ref findCycleMean() must be called before using this function.
-    bool findCycle() {
-      if (_cycle_node == INVALID) return false;
-      IntNodeMap reached(_gr, -1);
-      int r = _data[_cycle_node].size();
-      Node u = _cycle_node;
-      while (reached[u] < 0) {
-        reached[u] = --r;
-        u = _gr.source(_data[u][r].pred);
-      }
-      r = reached[u];
-      Arc e = _data[u][r].pred;
-      _cycle_path->addFront(e);
-      _cycle_cost = _cost[e];
-      _cycle_size = 1;
-      Node v;
-      while ((v = _gr.source(e)) != u) {
-        e = _data[v][--r].pred;
-        _cycle_path->addFront(e);
-        _cycle_cost += _cost[e];
-        ++_cycle_size;
-      }
-      return true;
-    }
-
-    /// @}
-
-    /// \name Query Functions
-    /// The results of the algorithm can be obtained using these
-    /// functions.\n
-    /// The algorithm should be executed before using them.
-
-    /// @{
-
-    /// \brief Return the total cost of the found cycle.
-    ///
-    /// This function returns the total cost of the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    Cost cycleCost() const {
-      return static_cast<Cost>(_cycle_cost);
-    }
-
-    /// \brief Return the number of arcs on the found cycle.
-    ///
-    /// This function returns the number of arcs on the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    int cycleSize() const {
-      return _cycle_size;
-    }
-
-    /// \brief Return the mean cost of the found cycle.
-    ///
-    /// This function returns the mean cost of the found cycle.
-    ///
-    /// \note <tt>alg.cycleMean()</tt> is just a shortcut of the
-    /// following code.
-    /// \code
-    ///   return static_cast<double>(alg.cycleCost()) / alg.cycleSize();
-    /// \endcode
-    ///
-    /// \pre \ref run() or \ref findCycleMean() must be called before
-    /// using this function.
-    double cycleMean() const {
-      return static_cast<double>(_cycle_cost) / _cycle_size;
-    }
-
-    /// \brief Return the found cycle.
-    ///
-    /// This function returns a const reference to the path structure
-    /// storing the found cycle.
-    ///
-    /// \pre \ref run() or \ref findCycle() must be called before using
-    /// this function.
-    const Path& cycle() const {
-      return *_cycle_path;
-    }
-
-    ///@}
-
-  private:
-
-    // Initialization
-    void init() {
-      if (!_cycle_path) {
-        _local_path = true;
-        _cycle_path = new Path;
-      }
-      _cycle_path->clear();
-      _cycle_cost = 0;
-      _cycle_size = 1;
-      _cycle_node = INVALID;
-      for (NodeIt u(_gr); u != INVALID; ++u)
-        _data[u].clear();
-    }
-
-    // Find strongly connected components and initialize _comp_nodes
-    // and _out_arcs
-    void findComponents() {
-      _comp_num = stronglyConnectedComponents(_gr, _comp);
-      _comp_nodes.resize(_comp_num);
-      if (_comp_num == 1) {
-        _comp_nodes[0].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          _comp_nodes[0].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            _out_arcs[n].push_back(a);
-          }
-        }
-      } else {
-        for (int i = 0; i < _comp_num; ++i)
-          _comp_nodes[i].clear();
-        for (NodeIt n(_gr); n != INVALID; ++n) {
-          int k = _comp[n];
-          _comp_nodes[k].push_back(n);
-          _out_arcs[n].clear();
-          for (OutArcIt a(_gr, n); a != INVALID; ++a) {
-            if (_comp[_gr.target(a)] == k) _out_arcs[n].push_back(a);
-          }
-        }
-      }
-    }
-
-    // Initialize path data for the current component
-    bool initComponent(int comp) {
-      _nodes = &(_comp_nodes[comp]);
-      int n = _nodes->size();
-      if (n < 1 || (n == 1 && _out_arcs[(*_nodes)[0]].size() == 0)) {
-        return false;
-      }
-      for (int i = 0; i < n; ++i) {
-        _data[(*_nodes)[i]].resize(n + 1, PathData(INF));
-      }
-      return true;
-    }
-
-    // Process all rounds of computing path data for the current component.
-    // _data[v][k] is the cost of a shortest directed walk from the root
-    // node to node v containing exactly k arcs.
-    void processRounds() {
-      Node start = (*_nodes)[0];
-      _data[start][0] = PathData(0);
-      _process.clear();
-      _process.push_back(start);
-
-      int k, n = _nodes->size();
-      for (k = 1; k <= n && int(_process.size()) < n; ++k) {
-        processNextBuildRound(k);
-      }
-      for ( ; k <= n; ++k) {
-        processNextFullRound(k);
-      }
-    }
-
-    // Process one round and rebuild _process
-    void processNextBuildRound(int k) {
-      std::vector<Node> next;
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_process.size()); ++i) {
-        u = _process[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            if (_data[v][k].dist == INF) next.push_back(v);
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-      _process.swap(next);
-    }
-
-    // Process one round using _nodes instead of _process
-    void processNextFullRound(int k) {
-      Node u, v;
-      Arc e;
-      LargeCost d;
-      for (int i = 0; i < int(_nodes->size()); ++i) {
-        u = (*_nodes)[i];
-        for (int j = 0; j < int(_out_arcs[u].size()); ++j) {
-          e = _out_arcs[u][j];
-          v = _gr.target(e);
-          d = _data[u][k-1].dist + _cost[e];
-          if (_tolerance.less(d, _data[v][k].dist)) {
-            _data[v][k] = PathData(d, e);
-          }
-        }
-      }
-    }
-
-    // Update the minimum cycle mean
-    void updateMinMean() {
-      int n = _nodes->size();
-      for (int i = 0; i < n; ++i) {
-        Node u = (*_nodes)[i];
-        if (_data[u][n].dist == INF) continue;
-        LargeCost cost, max_cost = 0;
-        int size, max_size = 1;
-        bool found_curr = false;
-        for (int k = 0; k < n; ++k) {
-          if (_data[u][k].dist == INF) continue;
-          cost = _data[u][n].dist - _data[u][k].dist;
-          size = n - k;
-          if (!found_curr || cost * max_size > max_cost * size) {
-            found_curr = true;
-            max_cost = cost;
-            max_size = size;
-          }
-        }
-        if ( found_curr && (_cycle_node == INVALID ||
-             max_cost * _cycle_size < _cycle_cost * max_size) ) {
-          _cycle_cost = max_cost;
-          _cycle_size = max_size;
-          _cycle_node = u;
-        }
-      }
-    }
-
-  }; //class KarpMmc
-
-  ///@}
-
-} //namespace lemon
-
-#endif //LEMON_KARP_MMC_H
Index: lemon/kruskal.h
===================================================================
--- lemon/kruskal.h	(revision 921)
+++ lemon/kruskal.h	(revision 584)
@@ -31,4 +31,7 @@
 ///\file
 ///\brief Kruskal's algorithm to compute a minimum cost spanning tree
+///
+///Kruskal's algorithm to compute a minimum cost spanning tree.
+///
 
 namespace lemon {
Index: lemon/lemon.pc.cmake
===================================================================
--- lemon/lemon.pc.cmake	(revision 908)
+++ lemon/lemon.pc.cmake	(revision 908)
@@ -0,0 +1,10 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@/bin
+libdir=@CMAKE_INSTALL_PREFIX@/lib
+includedir=@CMAKE_INSTALL_PREFIX@/include
+
+Name: @PROJECT_NAME@
+Description: Library for Efficient Modeling and Optimization in Networks
+Version: @PROJECT_VERSION@
+Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
+Cflags: -I${includedir}
Index: lemon/lemon.pc.in
===================================================================
--- lemon/lemon.pc.in	(revision 981)
+++ lemon/lemon.pc.in	(revision 658)
@@ -1,10 +1,10 @@
-prefix=@CMAKE_INSTALL_PREFIX@
-exec_prefix=@CMAKE_INSTALL_PREFIX@/bin
-libdir=@CMAKE_INSTALL_PREFIX@/lib
-includedir=@CMAKE_INSTALL_PREFIX@/include
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
 
-Name: @PROJECT_NAME@
+Name: @PACKAGE_NAME@
 Description: Library for Efficient Modeling and Optimization in Networks
-Version: @PROJECT_VERSION@
+Version: @PACKAGE_VERSION@
 Libs: -L${libdir} -lemon @GLPK_LIBS@ @CPLEX_LIBS@ @SOPLEX_LIBS@ @CLP_LIBS@ @CBC_LIBS@
 Cflags: -I${includedir}
Index: lemon/lgf_reader.h
===================================================================
--- lemon/lgf_reader.h	(revision 966)
+++ lemon/lgf_reader.h	(revision 959)
@@ -428,5 +428,5 @@
   ///\endcode
   ///
-  /// By default, the reader uses the first section in the file of the
+  /// By default the reader uses the first section in the file of the
   /// proper type. If a section has an optional name, then it can be
   /// selected for reading by giving an optional name parameter to the
@@ -563,5 +563,5 @@
     friend DigraphReader<TDGR> digraphReader(TDGR& digraph, std::istream& is);
     template <typename TDGR>
-    friend DigraphReader<TDGR> digraphReader(TDGR& digraph,
+    friend DigraphReader<TDGR> digraphReader(TDGR& digraph, 
                                              const std::string& fn);
     template <typename TDGR>
@@ -1195,5 +1195,5 @@
 
   };
-
+  
   /// \ingroup lemon_io
   ///
@@ -1202,5 +1202,5 @@
   /// This function just returns a \ref DigraphReader class.
   ///
-  /// With this function a digraph can be read from an
+  /// With this function a digraph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is network flow problem on a
@@ -1257,5 +1257,5 @@
   template <typename GR>
   class GraphReader;
-
+ 
   template <typename TGR>
   GraphReader<TGR> graphReader(TGR& graph, std::istream& is = std::cin);
@@ -1394,5 +1394,5 @@
     friend GraphReader<TGR> graphReader(TGR& graph, std::istream& is);
     template <typename TGR>
-    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn);
+    friend GraphReader<TGR> graphReader(TGR& graph, const std::string& fn); 
     template <typename TGR>
     friend GraphReader<TGR> graphReader(TGR& graph, const char *fn);
@@ -2078,7 +2078,7 @@
   /// \brief Return a \ref GraphReader class
   ///
-  /// This function just returns a \ref GraphReader class.
-  ///
-  /// With this function a graph can be read from an
+  /// This function just returns a \ref GraphReader class. 
+  ///
+  /// With this function a graph can be read from an 
   /// \ref lgf-format "LGF" file or input stream with several maps and
   /// attributes. For example, there is weighted matching problem on a
@@ -2236,5 +2236,5 @@
     /// whitespaces are trimmed from each processed string.
     ///
-    /// For example, let's see a section, which contain several
+    /// For example let's see a section, which contain several
     /// integers, which should be inserted into a vector.
     ///\code
Index: lemon/lgf_writer.h
===================================================================
--- lemon/lgf_writer.h	(revision 877)
+++ lemon/lgf_writer.h	(revision 599)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -352,5 +352,5 @@
 
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                    std::ostream& os = std::cout);
   template <typename TDGR>
@@ -505,5 +505,5 @@
 
     template <typename TDGR>
-    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+    friend DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                              std::ostream& os);
     template <typename TDGR>
@@ -918,5 +918,5 @@
   /// \brief Return a \ref DigraphWriter class
   ///
-  /// This function just returns a \ref DigraphWriter class.
+  /// This function just returns a \ref DigraphWriter class. 
   ///
   /// With this function a digraph can be write to a file or output
@@ -958,5 +958,5 @@
   /// \sa digraphWriter(const TDGR& digraph, std::ostream& os)
   template <typename TDGR>
-  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph,
+  DigraphWriter<TDGR> digraphWriter(const TDGR& digraph, 
                                     const std::string& fn) {
     DigraphWriter<TDGR> tmp(digraph, fn);
@@ -1102,9 +1102,9 @@
     friend GraphWriter<TGR> graphWriter(const TGR& graph, std::ostream& os);
     template <typename TGR>
-    friend GraphWriter<TGR> graphWriter(const TGR& graph,
+    friend GraphWriter<TGR> graphWriter(const TGR& graph, 
                                         const std::string& fn);
     template <typename TGR>
     friend GraphWriter<TGR> graphWriter(const TGR& graph, const char *fn);
-
+    
     GraphWriter(GraphWriter& other)
       : _os(other._os), local_os(other.local_os), _graph(other._graph),
@@ -1557,5 +1557,5 @@
   /// \brief Return a \ref GraphWriter class
   ///
-  /// This function just returns a \ref GraphWriter class.
+  /// This function just returns a \ref GraphWriter class. 
   ///
   /// With this function a graph can be write to a file or output
Index: lemon/list_graph.h
===================================================================
--- lemon/list_graph.h	(revision 877)
+++ lemon/list_graph.h	(revision 617)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -22,5 +22,5 @@
 ///\ingroup graphs
 ///\file
-///\brief ListDigraph and ListGraph classes.
+///\brief ListDigraph, ListGraph classes.
 
 #include <lemon/core.h>
@@ -32,6 +32,4 @@
 
 namespace lemon {
-
-  class ListDigraph;
 
   class ListDigraphBase {
@@ -65,5 +63,4 @@
     class Node {
       friend class ListDigraphBase;
-      friend class ListDigraph;
     protected:
 
@@ -81,5 +78,4 @@
     class Arc {
       friend class ListDigraphBase;
-      friend class ListDigraph;
     protected:
 
@@ -121,18 +117,18 @@
       int n;
       for(n = first_node;
-          n != -1 && nodes[n].first_out == -1;
+          n!=-1 && nodes[n].first_in == -1;
           n = nodes[n].next) {}
-      arc.id = (n == -1) ? -1 : nodes[n].first_out;
+      arc.id = (n == -1) ? -1 : nodes[n].first_in;
     }
 
     void next(Arc& arc) const {
-      if (arcs[arc.id].next_out != -1) {
-        arc.id = arcs[arc.id].next_out;
+      if (arcs[arc.id].next_in != -1) {
+        arc.id = arcs[arc.id].next_in;
       } else {
         int n;
-        for(n = nodes[arcs[arc.id].source].next;
-            n != -1 && nodes[n].first_out == -1;
+        for(n = nodes[arcs[arc.id].target].next;
+            n!=-1 && nodes[n].first_in == -1;
             n = nodes[n].next) {}
-        arc.id = (n == -1) ? -1 : nodes[n].first_out;
+        arc.id = (n == -1) ? -1 : nodes[n].first_in;
       }
     }
@@ -316,25 +312,29 @@
   ///A general directed graph structure.
 
-  ///\ref ListDigraph is a versatile and fast directed graph
-  ///implementation based on linked lists that are stored in
+  ///\ref ListDigraph is a simple and fast <em>directed graph</em>
+  ///implementation based on static linked lists that are stored in
   ///\c std::vector structures.
   ///
-  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
+  ///It conforms to the \ref concepts::Digraph "Digraph concept" and it
+  ///also provides several useful additional functionalities.
+  ///Most of the member functions and nested classes are documented
   ///only in the concept class.
   ///
-  ///This class provides only linear time counting for nodes and arcs.
-  ///
   ///\sa concepts::Digraph
-  ///\sa ListGraph
+
   class ListDigraph : public ExtendedListDigraphBase {
     typedef ExtendedListDigraphBase Parent;
 
   private:
-    /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
+    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
+
+    ///ListDigraph is \e not copy constructible. Use copyDigraph() instead.
+    ///
     ListDigraph(const ListDigraph &) :ExtendedListDigraphBase() {};
-    /// \brief Assignment of a digraph to another one is \e not allowed.
-    /// Use DigraphCopy instead.
+    ///\brief Assignment of ListDigraph to another one is \e not allowed.
+    ///Use copyDigraph() instead.
+
+    ///Assignment of ListDigraph to another one is \e not allowed.
+    ///Use copyDigraph() instead.
     void operator=(const ListDigraph &) {}
   public:
@@ -348,5 +348,5 @@
     ///Add a new node to the digraph.
 
-    ///This function adds a new node to the digraph.
+    ///Add a new node to the digraph.
     ///\return The new node.
     Node addNode() { return Parent::addNode(); }
@@ -354,8 +354,8 @@
     ///Add a new arc to the digraph.
 
-    ///This function adds a new arc to the digraph with source node \c s
+    ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return The new arc.
-    Arc addArc(Node s, Node t) {
+    Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
     }
@@ -363,43 +363,41 @@
     ///\brief Erase a node from the digraph.
     ///
-    ///This function erases the given node along with its outgoing and
-    ///incoming arcs from the digraph.
-    ///
-    ///\note All iterators referencing the removed node or the connected
-    ///arcs are invalidated, of course.
-    void erase(Node n) { Parent::erase(n); }
+    ///Erase a node from the digraph.
+    ///
+    void erase(const Node& n) { Parent::erase(n); }
 
     ///\brief Erase an arc from the digraph.
     ///
-    ///This function erases the given arc from the digraph.
-    ///
-    ///\note All iterators referencing the removed arc are invalidated,
-    ///of course.
-    void erase(Arc a) { Parent::erase(a); }
+    ///Erase an arc from the digraph.
+    ///
+    void erase(const Arc& a) { Parent::erase(a); }
 
     /// Node validity check
 
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the digraph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
-    /// added to the digraph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
+    ///
+    /// \warning A Node pointing to a removed item
+    /// could become valid again later if new nodes are
+    /// added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
     /// Arc validity check
 
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the digraph.
-    ///
-    /// \warning A removed arc could become valid again if new arcs are
-    /// added to the digraph.
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning An Arc pointing to a removed item
+    /// could become valid again later if new nodes are
+    /// added to the graph.
     bool valid(Arc a) const { return Parent::valid(a); }
 
-    /// Change the target node of an arc
-
-    /// This function changes the target node of the given arc \c a to \c n.
-    ///
-    ///\note \c ArcIt and \c OutArcIt iterators referencing the changed
-    ///arc remain valid, but \c InArcIt iterators are invalidated.
+    /// Change the target of \c a to \c n
+
+    /// Change the target of \c a to \c n
+    ///
+    ///\note The <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s referencing
+    ///the changed arc remain valid. However <tt>InArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
@@ -408,10 +406,11 @@
       Parent::changeTarget(a,n);
     }
-    /// Change the source node of an arc
-
-    /// This function changes the source node of the given arc \c a to \c n.
-    ///
-    ///\note \c InArcIt iterators referencing the changed arc remain
-    ///valid, but \c ArcIt and \c OutArcIt iterators are invalidated.
+    /// Change the source of \c a to \c n
+
+    /// Change the source of \c a to \c n
+    ///
+    ///\note The <tt>InArcIt</tt>s referencing the changed arc remain
+    ///valid. However the <tt>ArcIt</tt>s and <tt>OutArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
@@ -421,74 +420,92 @@
     }
 
-    /// Reverse the direction of an arc.
-
-    /// This function reverses the direction of the given arc.
-    ///\note \c ArcIt, \c OutArcIt and \c InArcIt iterators referencing
-    ///the changed arc are invalidated.
+    /// Invert the direction of an arc.
+
+    ///\note The <tt>ArcIt</tt>s referencing the changed arc remain
+    ///valid. However <tt>OutArcIt</tt>s and <tt>InArcIt</tt>s are
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
-    void reverseArc(Arc a) {
-      Node t=target(a);
-      changeTarget(a,source(a));
-      changeSource(a,t);
-    }
+    void reverseArc(Arc e) {
+      Node t=target(e);
+      changeTarget(e,source(e));
+      changeSource(e,t);
+    }
+
+    /// Reserve memory for nodes.
+
+    /// Using this function it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveArc
+    void reserveNode(int n) { nodes.reserve(n); };
+
+    /// Reserve memory for arcs.
+
+    /// Using this function it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveNode
+    void reserveArc(int m) { arcs.reserve(m); };
 
     ///Contract two nodes.
 
-    ///This function contracts the given two nodes.
-    ///Node \c v is removed, but instead of deleting its
-    ///incident arcs, they are joined to node \c u.
-    ///If the last parameter \c r is \c true (this is the default value),
-    ///then the newly created loops are removed.
-    ///
-    ///\note The moved arcs are joined to node \c u using changeSource()
-    ///or changeTarget(), thus \c ArcIt and \c OutArcIt iterators are
-    ///invalidated for the outgoing arcs of node \c v and \c InArcIt
-    ///iterators are invalidated for the incomming arcs of \c v.
-    ///Moreover all iterators referencing node \c v or the removed
-    ///loops are also invalidated. Other iterators remain valid.
+    ///This function contracts two nodes.
+    ///Node \p b will be removed but instead of deleting
+    ///incident arcs, they will be joined to \p a.
+    ///The last parameter \p r controls whether to remove loops. \c true
+    ///means that loops will be removed.
+    ///
+    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
+    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s
+    ///may be invalidated.
     ///
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
-    void contract(Node u, Node v, bool r = true)
+    void contract(Node a, Node b, bool r = true)
     {
-      for(OutArcIt e(*this,v);e!=INVALID;) {
+      for(OutArcIt e(*this,b);e!=INVALID;) {
         OutArcIt f=e;
         ++f;
-        if(r && target(e)==u) erase(e);
-        else changeSource(e,u);
+        if(r && target(e)==a) erase(e);
+        else changeSource(e,a);
         e=f;
       }
-      for(InArcIt e(*this,v);e!=INVALID;) {
+      for(InArcIt e(*this,b);e!=INVALID;) {
         InArcIt f=e;
         ++f;
-        if(r && source(e)==u) erase(e);
-        else changeTarget(e,u);
+        if(r && source(e)==a) erase(e);
+        else changeTarget(e,a);
         e=f;
       }
-      erase(v);
+      erase(b);
     }
 
     ///Split a node.
 
-    ///This function splits the given node. First, a new node is added
-    ///to the digraph, then the source of each outgoing arc of node \c n
-    ///is moved to this new node.
-    ///If the second parameter \c connect is \c true (this is the default
-    ///value), then a new arc from node \c n to the newly created node
-    ///is also added.
+    ///This function splits a node. First a new node is added to the digraph,
+    ///then the source of each outgoing arc of \c n is moved to this new node.
+    ///If \c connect is \c true (this is the default value), then a new arc
+    ///from \c n to the newly created node is also added.
     ///\return The newly created node.
     ///
-    ///\note All iterators remain valid.
-    ///
-    ///\warning This functionality cannot be used together with the
+    ///\note The <tt>ArcIt</tt>s referencing a moved arc remain
+    ///valid. However <tt>InArcIt</tt>s and <tt>OutArcIt</tt>s may
+    ///be invalidated.
+    ///
+    ///\warning This functionality cannot be used in conjunction with the
     ///Snapshot feature.
     Node split(Node n, bool connect = true) {
       Node b = addNode();
-      nodes[b.id].first_out=nodes[n.id].first_out;
-      nodes[n.id].first_out=-1;
-      for(int i=nodes[b.id].first_out; i!=-1; i=arcs[i].next_out) {
-        arcs[i].source=b.id;
+      for(OutArcIt e(*this,n);e!=INVALID;) {
+        OutArcIt f=e;
+        ++f;
+        changeSource(e,b);
+        e=f;
       }
       if (connect) addArc(n,b);
@@ -498,50 +515,18 @@
     ///Split an arc.
 
-    ///This function splits the given arc. First, a new node \c v is
-    ///added to the digraph, then the target node of the original arc
-    ///is set to \c v. Finally, an arc from \c v to the original target
-    ///is added.
+    ///This function splits an arc. First a new node \c b is added to
+    ///the digraph, then the original arc is re-targeted to \c
+    ///b. Finally an arc from \c b to the original target is added.
+    ///
     ///\return The newly created node.
-    ///
-    ///\note \c InArcIt iterators referencing the original arc are
-    ///invalidated. Other iterators remain valid.
     ///
     ///\warning This functionality cannot be used together with the
     ///Snapshot feature.
-    Node split(Arc a) {
-      Node v = addNode();
-      addArc(v,target(a));
-      changeTarget(a,v);
-      return v;
-    }
-
-    ///Clear the digraph.
-
-    ///This function erases all nodes and arcs from the digraph.
-    ///
-    ///\note All iterators of the digraph are invalidated, of course.
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for arcs.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
+    Node split(Arc e) {
+      Node b = addNode();
+      addArc(b,target(e));
+      changeTarget(e,b);
+      return b;
+    }
 
     /// \brief Class to make a snapshot of the digraph and restore
@@ -553,13 +538,7 @@
     /// restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state,
-    /// i.e. you cannot add the removed nodes and arcs again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and arc deletions and other modifications (e.g.
-    /// reversing, contracting, splitting arcs or nodes) cannot be
+    /// \warning Arc and node deletions and other modifications (e.g.
+    /// contracting, splitting, reversing arcs or nodes) cannot be
     /// restored. These events invalidate the snapshot.
-    /// However, the arcs and nodes that were added to the digraph after
-    /// making the current snapshot can be removed without invalidating it.
     class Snapshot {
     protected:
@@ -731,5 +710,5 @@
       ///
       /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
+      /// To actually make a snapshot you must call save().
       Snapshot()
         : digraph(0), node_observer_proxy(*this),
@@ -738,31 +717,30 @@
       /// \brief Constructor that immediately makes a snapshot.
       ///
-      /// This constructor immediately makes a snapshot of the given digraph.
-      Snapshot(ListDigraph &gr)
+      /// This constructor immediately makes a snapshot of the digraph.
+      /// \param _digraph The digraph we make a snapshot of.
+      Snapshot(ListDigraph &_digraph)
         : node_observer_proxy(*this),
           arc_observer_proxy(*this) {
-        attach(gr);
+        attach(_digraph);
       }
 
       /// \brief Make a snapshot.
       ///
-      /// This function makes a snapshot of the given digraph.
-      /// It can be called more than once. In case of a repeated
+      /// Make a snapshot of the digraph.
+      ///
+      /// This function can be called more than once. In case of a repeated
       /// call, the previous snapshot gets lost.
-      void save(ListDigraph &gr) {
+      /// \param _digraph The digraph we make the snapshot of.
+      void save(ListDigraph &_digraph) {
         if (attached()) {
           detach();
           clear();
         }
-        attach(gr);
+        attach(_digraph);
       }
 
       /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListDigraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
+      //
+      /// Undo the changes until the last snapshot created by save().
       void restore() {
         detach();
@@ -778,7 +756,7 @@
       }
 
-      /// \brief Returns \c true if the snapshot is valid.
+      /// \brief Gives back true when the snapshot is valid.
       ///
-      /// This function returns \c true if the snapshot is valid.
+      /// Gives back true when the snapshot is valid.
       bool valid() const {
         return attached();
@@ -817,4 +795,8 @@
 
     typedef ListGraphBase Graph;
+
+    class Node;
+    class Arc;
+    class Edge;
 
     class Node {
@@ -866,4 +848,6 @@
       bool operator<(const Arc& arc) const {return id < arc.id;}
     };
+
+
 
     ListGraphBase()
@@ -1181,25 +1165,29 @@
   ///A general undirected graph structure.
 
-  ///\ref ListGraph is a versatile and fast undirected graph
-  ///implementation based on linked lists that are stored in
+  ///\ref ListGraph is a simple and fast <em>undirected graph</em>
+  ///implementation based on static linked lists that are stored in
   ///\c std::vector structures.
   ///
-  ///This type fully conforms to the \ref concepts::Graph "Graph concept"
-  ///and it also provides several useful additional functionalities.
-  ///Most of its member functions and nested classes are documented
+  ///It conforms to the \ref concepts::Graph "Graph concept" and it
+  ///also provides several useful additional functionalities.
+  ///Most of the member functions and nested classes are documented
   ///only in the concept class.
   ///
-  ///This class provides only linear time counting for nodes, edges and arcs.
-  ///
   ///\sa concepts::Graph
-  ///\sa ListDigraph
+
   class ListGraph : public ExtendedListGraphBase {
     typedef ExtendedListGraphBase Parent;
 
   private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
+    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
+
+    ///ListGraph is \e not copy constructible. Use copyGraph() instead.
+    ///
     ListGraph(const ListGraph &) :ExtendedListGraphBase()  {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
+    ///\brief Assignment of ListGraph to another one is \e not allowed.
+    ///Use copyGraph() instead.
+
+    ///Assignment of ListGraph to another one is \e not allowed.
+    ///Use copyGraph() instead.
     void operator=(const ListGraph &) {}
   public:
@@ -1214,5 +1202,5 @@
     /// \brief Add a new node to the graph.
     ///
-    /// This function adds a new node to the graph.
+    /// Add a new node to the graph.
     /// \return The new node.
     Node addNode() { return Parent::addNode(); }
@@ -1220,60 +1208,57 @@
     /// \brief Add a new edge to the graph.
     ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
+    /// Add a new edge to the graph with source node \c s
+    /// and target node \c t.
     /// \return The new edge.
-    Edge addEdge(Node u, Node v) {
-      return Parent::addEdge(u, v);
-    }
-
-    ///\brief Erase a node from the graph.
-    ///
-    /// This function erases the given node along with its incident arcs
-    /// from the graph.
-    ///
-    /// \note All iterators referencing the removed node or the incident
-    /// edges are invalidated, of course.
-    void erase(Node n) { Parent::erase(n); }
-
-    ///\brief Erase an edge from the graph.
-    ///
-    /// This function erases the given edge from the graph.
-    ///
-    /// \note All iterators referencing the removed edge are invalidated,
-    /// of course.
-    void erase(Edge e) { Parent::erase(e); }
+    Edge addEdge(const Node& s, const Node& t) {
+      return Parent::addEdge(s, t);
+    }
+
+    /// \brief Erase a node from the graph.
+    ///
+    /// Erase a node from the graph.
+    ///
+    void erase(const Node& n) { Parent::erase(n); }
+
+    /// \brief Erase an edge from the graph.
+    ///
+    /// Erase an edge from the graph.
+    ///
+    void erase(const Edge& e) { Parent::erase(e); }
     /// Node validity check
 
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
-    ///
-    /// \warning A removed node could become valid again if new nodes are
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
+    ///
+    /// \warning A Node pointing to a removed item
+    /// could become valid again later if new nodes are
     /// added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
+    /// Arc validity check
+
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning An Arc pointing to a removed item
+    /// could become valid again later if new edges are
+    /// added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
     /// Edge validity check
 
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
-    ///
-    /// \warning A removed edge could become valid again if new edges are
+    /// This function gives back true if the given edge is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning A Edge pointing to a removed item
+    /// could become valid again later if new edges are
     /// added to the graph.
     bool valid(Edge e) const { return Parent::valid(e); }
-    /// Arc validity check
-
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc could become valid again if new edges are
-    /// added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
-    /// \brief Change the first node of an edge.
-    ///
-    /// This function changes the first node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt and \c ArcIt iterators referencing the
-    ///changed edge are invalidated and all other iterators whose
-    ///base node is the changed node are also invalidated.
+    /// \brief Change the end \c u of \c e to \c n
+    ///
+    /// This function changes the end \c u of \c e to node \c n.
+    ///
+    ///\note The <tt>EdgeIt</tt>s and <tt>ArcIt</tt>s referencing the
+    ///changed edge are invalidated and if the changed node is the
+    ///base node of an iterator then this iterator is also
+    ///invalidated.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1282,12 +1267,11 @@
       Parent::changeU(e,n);
     }
-    /// \brief Change the second node of an edge.
-    ///
-    /// This function changes the second node of the given edge \c e to \c n.
-    ///
-    ///\note \c EdgeIt iterators referencing the changed edge remain
-    ///valid, but \c ArcIt iterators referencing the changed edge and
-    ///all other iterators whose base node is the changed node are also
-    ///invalidated.
+    /// \brief Change the end \c v of \c e to \c n
+    ///
+    /// This function changes the end \c v of \c e to \c n.
+    ///
+    ///\note The <tt>EdgeIt</tt>s referencing the changed edge remain
+    ///valid, however <tt>ArcIt</tt>s and if the changed node is the
+    ///base node of an iterator then this iterator is invalidated.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1296,18 +1280,14 @@
       Parent::changeV(e,n);
     }
-
     /// \brief Contract two nodes.
     ///
-    /// This function contracts the given two nodes.
-    /// Node \c b is removed, but instead of deleting
-    /// its incident edges, they are joined to node \c a.
-    /// If the last parameter \c r is \c true (this is the default value),
-    /// then the newly created loops are removed.
-    ///
-    /// \note The moved edges are joined to node \c a using changeU()
-    /// or changeV(), thus all edge and arc iterators whose base node is
-    /// \c b are invalidated.
-    /// Moreover all iterators referencing node \c b or the removed
-    /// loops are also invalidated. Other iterators remain valid.
+    /// This function contracts two nodes.
+    /// Node \p b will be removed but instead of deleting
+    /// its neighboring arcs, they will be joined to \p a.
+    /// The last parameter \p r controls whether to remove loops. \c true
+    /// means that loops will be removed.
+    ///
+    /// \note The <tt>ArcIt</tt>s referencing a moved arc remain
+    /// valid.
     ///
     ///\warning This functionality cannot be used together with the
@@ -1328,32 +1308,4 @@
     }
 
-    ///Clear the graph.
-
-    ///This function erases all nodes and arcs from the graph.
-    ///
-    ///\note All iterators of the graph are invalidated, of course.
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
     /// \brief Class to make a snapshot of the graph and restore
@@ -1365,13 +1317,7 @@
     /// using the restore() function.
     ///
-    /// \note After a state is restored, you cannot restore a later state,
-    /// i.e. you cannot add the removed nodes and edges again using
-    /// another Snapshot instance.
-    ///
-    /// \warning Node and edge deletions and other modifications
-    /// (e.g. changing the end-nodes of edges or contracting nodes)
-    /// cannot be restored. These events invalidate the snapshot.
-    /// However, the edges and nodes that were added to the graph after
-    /// making the current snapshot can be removed without invalidating it.
+    /// \warning Edge and node deletions and other modifications
+    /// (e.g. changing nodes of edges, contracting nodes) cannot be
+    /// restored. These events invalidate the snapshot.
     class Snapshot {
     protected:
@@ -1543,5 +1489,5 @@
       ///
       /// Default constructor.
-      /// You have to call save() to actually make a snapshot.
+      /// To actually make a snapshot you must call save().
       Snapshot()
         : graph(0), node_observer_proxy(*this),
@@ -1550,31 +1496,30 @@
       /// \brief Constructor that immediately makes a snapshot.
       ///
-      /// This constructor immediately makes a snapshot of the given graph.
-      Snapshot(ListGraph &gr)
+      /// This constructor immediately makes a snapshot of the graph.
+      /// \param _graph The graph we make a snapshot of.
+      Snapshot(ListGraph &_graph)
         : node_observer_proxy(*this),
           edge_observer_proxy(*this) {
-        attach(gr);
+        attach(_graph);
       }
 
       /// \brief Make a snapshot.
       ///
-      /// This function makes a snapshot of the given graph.
-      /// It can be called more than once. In case of a repeated
+      /// Make a snapshot of the graph.
+      ///
+      /// This function can be called more than once. In case of a repeated
       /// call, the previous snapshot gets lost.
-      void save(ListGraph &gr) {
+      /// \param _graph The graph we make the snapshot of.
+      void save(ListGraph &_graph) {
         if (attached()) {
           detach();
           clear();
         }
-        attach(gr);
+        attach(_graph);
       }
 
       /// \brief Undo the changes until the last snapshot.
-      ///
-      /// This function undos the changes until the last snapshot
-      /// created by save() or Snapshot(ListGraph&).
-      ///
-      /// \warning This method invalidates the snapshot, i.e. repeated
-      /// restoring is not supported unless you call save() again.
+      //
+      /// Undo the changes until the last snapshot created by save().
       void restore() {
         detach();
@@ -1590,7 +1535,7 @@
       }
 
-      /// \brief Returns \c true if the snapshot is valid.
+      /// \brief Gives back true when the snapshot is valid.
       ///
-      /// This function returns \c true if the snapshot is valid.
+      /// Gives back true when the snapshot is valid.
       bool valid() const {
         return attached();
Index: lemon/lp.h
===================================================================
--- lemon/lp.h	(revision 877)
+++ lemon/lp.h	(revision 627)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -85,5 +85,5 @@
 #elif LEMON_HAVE_CLP
 # define DEFAULT_LP CLP
-  typedef ClpLp Lp;
+  typedef ClpLp Lp;  
 #endif
 #endif
Index: lemon/lp_base.cc
===================================================================
--- lemon/lp_base.cc	(revision 877)
+++ lemon/lp_base.cc	(revision 486)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: lemon/lp_base.h
===================================================================
--- lemon/lp_base.h	(revision 989)
+++ lemon/lp_base.h	(revision 988)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -83,5 +83,5 @@
       MESSAGE_VERBOSE
     };
-
+    
 
     ///The floating point type used by the solver
@@ -115,12 +115,12 @@
       typedef True LpCol;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Col to an
       /// undefined value.
       Col() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Col to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Col(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -147,5 +147,5 @@
     ///Iterator for iterate over the columns of an LP problem
 
-    /// Its usage is quite simple, for example, you can count the number
+    /// Its usage is quite simple, for example you can count the number
     /// of columns in an LP \c lp:
     ///\code
@@ -157,10 +157,10 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       ColIt() {}
       /// Sets the iterator to the first Col
-
+      
       /// Sets the iterator to the first Col.
       ///
@@ -170,10 +170,10 @@
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       ColIt(const Invalid&) : Col(INVALID) {}
       /// Next column
-
+      
       /// Assign the iterator to the next column.
       ///
@@ -210,12 +210,12 @@
       typedef True LpRow;
       /// Default constructor
-
+      
       /// \warning The default constructor sets the Row to an
       /// undefined value.
       Row() {}
       /// Invalid constructor \& conversion.
-
+      
       /// This constructor initializes the Row to be invalid.
-      /// \sa Invalid for more details.
+      /// \sa Invalid for more details.      
       Row(const Invalid&) : _id(-1) {}
       /// Equality operator
@@ -225,5 +225,5 @@
       bool operator==(Row r) const  {return _id == r._id;}
       /// Inequality operator
-
+      
       /// \sa operator==(Row r)
       ///
@@ -242,5 +242,5 @@
     ///Iterator for iterate over the rows of an LP problem
 
-    /// Its usage is quite simple, for example, you can count the number
+    /// Its usage is quite simple, for example you can count the number
     /// of rows in an LP \c lp:
     ///\code
@@ -252,10 +252,10 @@
     public:
       /// Default constructor
-
+      
       /// \warning The default constructor sets the iterator
       /// to an undefined value.
       RowIt() {}
       /// Sets the iterator to the first Row
-
+      
       /// Sets the iterator to the first Row.
       ///
@@ -265,10 +265,10 @@
       }
       /// Invalid constructor \& conversion
-
+      
       /// Initialize the iterator to be invalid.
       /// \sa Invalid for more details.
       RowIt(const Invalid&) : Row(INVALID) {}
       /// Next row
-
+      
       /// Assign the iterator to the next row.
       ///
@@ -348,5 +348,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients and
       /// the constant component are initialized to zero.
@@ -449,7 +449,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -465,5 +465,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -482,5 +482,5 @@
         const Value& operator*() const { return _it->second; }
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -494,7 +494,7 @@
 
       /// Const iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -510,5 +510,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -525,5 +525,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -674,5 +674,5 @@
       typedef True SolverExpr;
       /// Default constructor
-
+      
       /// Construct an empty expression, the coefficients are
       /// initialized to zero.
@@ -709,5 +709,5 @@
       }
       /// \brief Removes the coefficients which's absolute value does
-      /// not exceed \c epsilon.
+      /// not exceed \c epsilon. 
       void simplify(Value epsilon = 0.0) {
         std::map<int, Value>::iterator it=comps.begin();
@@ -758,7 +758,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -774,5 +774,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -792,5 +792,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -804,7 +804,7 @@
 
       ///Iterator over the expression
-
-      ///The iterator iterates over the terms of the expression.
-      ///
+      
+      ///The iterator iterates over the terms of the expression. 
+      /// 
       ///\code
       ///double s=0;
@@ -820,5 +820,5 @@
 
         /// Sets the iterator to the first term
-
+        
         /// Sets the iterator to the first term of the expression.
         ///
@@ -835,5 +835,5 @@
 
         /// Next term
-
+        
         /// Assign the iterator to the next term.
         ///
@@ -943,12 +943,4 @@
     virtual int _addCol() = 0;
     virtual int _addRow() = 0;
-
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-      int row = _addRow();
-      _setRowCoeffs(row, b, e);
-      _setRowLowerBound(row, l);
-      _setRowUpperBound(row, u);
-      return row;
-    }
 
     virtual void _eraseCol(int col) = 0;
@@ -1216,8 +1208,6 @@
     ///\return The created row.
     Row addRow(Value l,const Expr &e, Value u) {
-      Row r;
-      e.simplify();
-      r._id = _addRowId(_addRow(l - *e, ExprIterator(e.comps.begin(), cols),
-                                ExprIterator(e.comps.end(), cols), u - *e));
+      Row r=addRow();
+      row(r,l,e,u);
       return r;
     }
@@ -1228,10 +1218,6 @@
     ///\return The created row.
     Row addRow(const Constr &c) {
-      Row r;
-      c.expr().simplify();
-      r._id = _addRowId(_addRow(c.lowerBounded()?c.lowerBound()-*c.expr():-INF,
-                                ExprIterator(c.expr().comps.begin(), cols),
-                                ExprIterator(c.expr().comps.end(), cols),
-                                c.upperBounded()?c.upperBound()-*c.expr():INF));
+      Row r=addRow();
+      row(r,c);
       return r;
     }
@@ -1818,8 +1804,8 @@
     enum VarStatus {
       /// The variable is in the basis
-      BASIC,
+      BASIC, 
       /// The variable is free, but not basic
       FREE,
-      /// The variable has active lower bound
+      /// The variable has active lower bound 
       LOWER,
       /// The variable has active upper bound
@@ -1900,5 +1886,5 @@
     }
     /// Returns a component of the primal ray
-
+    
     /// The primal ray is solution of the modified primal problem,
     /// where we change each finite bound to 0, and we looking for a
@@ -1934,5 +1920,5 @@
 
     /// Returns a component of the dual ray
-
+    
     /// The dual ray is solution of the modified primal problem, where
     /// we change each finite bound to 0 (i.e. the objective function
@@ -2076,5 +2062,5 @@
     }
     ///The value of the objective function
-
+    
     ///\return
     ///- \ref INF or -\ref INF means either infeasibility or unboundedness
Index: lemon/lp_skeleton.cc
===================================================================
--- lemon/lp_skeleton.cc	(revision 877)
+++ lemon/lp_skeleton.cc	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -29,9 +29,4 @@
 
   int SkeletonSolverBase::_addRow()
-  {
-    return ++row_num;
-  }
-
-  int SkeletonSolverBase::_addRow(Value, ExprIterator, ExprIterator, Value)
   {
     return ++row_num;
Index: lemon/lp_skeleton.h
===================================================================
--- lemon/lp_skeleton.h	(revision 877)
+++ lemon/lp_skeleton.h	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,5 @@
 ///\file
 ///\brief Skeleton file to implement LP/MIP solver interfaces
-///
+///  
 ///The classes in this file do nothing, but they can serve as skeletons when
 ///implementing an interface to new solvers.
@@ -30,5 +30,5 @@
 
   ///A skeleton class to implement LP/MIP solver base interface
-
+  
   ///This class does nothing, but it can serve as a skeleton when
   ///implementing an interface to new solvers.
@@ -45,6 +45,4 @@
     /// \e
     virtual int _addRow();
-    /// \e
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
     /// \e
     virtual void _eraseCol(int i);
Index: lemon/maps.h
===================================================================
--- lemon/maps.h	(revision 942)
+++ lemon/maps.h	(revision 684)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -23,5 +23,4 @@
 #include <functional>
 #include <vector>
-#include <map>
 
 #include <lemon/core.h>
@@ -30,4 +29,6 @@
 ///\ingroup maps
 ///\brief Miscellaneous property maps
+
+#include <map>
 
 namespace lemon {
@@ -57,5 +58,5 @@
   /// but data written to it is not required (i.e. it will be sent to
   /// <tt>/dev/null</tt>).
-  /// It conforms to the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
+  /// It conforms the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
   ///
   /// \sa ConstMap
@@ -90,5 +91,5 @@
   ///
   /// In other aspects it is equivalent to \c NullMap.
-  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
+  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
@@ -159,5 +160,5 @@
   ///
   /// In other aspects it is equivalent to \c NullMap.
-  /// So it conforms to the \ref concepts::ReadWriteMap "ReadWriteMap"
+  /// So it conforms the \ref concepts::ReadWriteMap "ReadWriteMap"
   /// concept, but it absorbs the data written to it.
   ///
@@ -231,7 +232,7 @@
   /// This map is essentially a wrapper for \c std::vector. It assigns
   /// values to integer keys from the range <tt>[0..size-1]</tt>.
-  /// It can be used together with some data structures, e.g.
-  /// heap types and \c UnionFind, when the used items are small
-  /// integers. This map conforms to the \ref concepts::ReferenceMap
+  /// It can be used with some data structures, for example
+  /// \c UnionFind, \c BinHeap, when the used items are small
+  /// integers. This map conforms the \ref concepts::ReferenceMap
   /// "ReferenceMap" concept.
   ///
@@ -341,5 +342,5 @@
   /// stored actually. This value can be different from the default
   /// contructed value (i.e. \c %Value()).
-  /// This type conforms to the \ref concepts::ReferenceMap "ReferenceMap"
+  /// This type conforms the \ref concepts::ReferenceMap "ReferenceMap"
   /// concept.
   ///
@@ -349,7 +350,7 @@
   /// The name of this type also refers to this important usage.
   ///
-  /// Apart form that, this map can be used in many other cases since it
+  /// Apart form that this map can be used in many other cases since it
   /// is based on \c std::map, which is a general associative container.
-  /// However, keep in mind that it is usually not as efficient as other
+  /// However keep in mind that it is usually not as efficient as other
   /// maps.
   ///
@@ -707,5 +708,5 @@
   /// The \c Key type of it is inherited from \c M and the \c Value
   /// type is \c V.
-  /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+  /// This type conforms the \ref concepts::ReadMap "ReadMap" concept.
   ///
   /// The simplest way of using this map is through the convertMap()
@@ -1786,13 +1787,13 @@
   /// The most important usage of it is storing certain nodes or arcs
   /// that were marked \c true by an algorithm.
-  /// For example, it makes easier to store the nodes in the processing
+  /// For example it makes easier to store the nodes in the processing
   /// order of Dfs algorithm, as the following examples show.
   /// \code
   ///   std::vector<Node> v;
-  ///   dfs(g).processedMap(loggerBoolMap(std::back_inserter(v))).run(s);
+  ///   dfs(g,s).processedMap(loggerBoolMap(std::back_inserter(v))).run();
   /// \endcode
   /// \code
   ///   std::vector<Node> v(countNodes(g));
-  ///   dfs(g).processedMap(loggerBoolMap(v.begin())).run(s);
+  ///   dfs(g,s).processedMap(loggerBoolMap(v.begin())).run();
   /// \endcode
   ///
@@ -1801,5 +1802,5 @@
   ///
   /// \note LoggerBoolMap is just \ref concepts::WriteMap "writable", so
-  /// it cannot be used when a readable map is needed, for example, as
+  /// it cannot be used when a readable map is needed, for example as
   /// \c ReachedMap for \c Bfs, \c Dfs and \c Dijkstra algorithms.
   ///
@@ -1818,5 +1819,5 @@
   ///
   /// IdMap provides a unique and immutable id for each item of the
-  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is
+  /// same type (\c Node, \c Arc or \c Edge) in a graph. This id is 
   ///  - \b unique: different items get different ids,
   ///  - \b immutable: the id of an item does not change (even if you
@@ -1826,5 +1827,5 @@
   /// the items stored in the graph, which is returned by the \c id()
   /// function of the graph. This map can be inverted with its member
-  /// class \c InverseMap or with the \c operator()() member.
+  /// class \c InverseMap or with the \c operator() member.
   ///
   /// \tparam GR The graph type.
@@ -1866,9 +1867,7 @@
   public:
 
-    /// \brief The inverse map type of IdMap.
-    ///
-    /// The inverse map type of IdMap. The subscript operator gives back
-    /// an item by its id.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+    /// \brief This class represents the inverse of its owner (IdMap).
+    ///
+    /// This class represents the inverse of its owner (IdMap).
     /// \see inverse()
     class InverseMap {
@@ -1885,7 +1884,7 @@
       explicit InverseMap(const IdMap& map) : _graph(map._graph) {}
 
-      /// \brief Gives back an item by its id.
+      /// \brief Gives back the given item from its id.
       ///
-      /// Gives back an item by its id.
+      /// Gives back the given item from its id.
       Item operator[](int id) const { return _graph->fromId(id, Item());}
 
@@ -1900,12 +1899,4 @@
   };
 
-  /// \brief Returns an \c IdMap class.
-  ///
-  /// This function just returns an \c IdMap class.
-  /// \relates IdMap
-  template <typename K, typename GR>
-  inline IdMap<GR, K> idMap(const GR& graph) {
-    return IdMap<GR, K>(graph);
-  }
 
   /// \brief General cross reference graph map type.
@@ -1914,15 +1905,6 @@
   /// It wraps a standard graph map (\c NodeMap, \c ArcMap or \c EdgeMap)
   /// and if a key is set to a new value, then stores it in the inverse map.
-  /// The graph items can be accessed by their values either using
-  /// \c InverseMap or \c operator()(), and the values of the map can be
-  /// accessed with an STL compatible forward iterator (\c ValueIt).
-  ///
-  /// This map is intended to be used when all associated values are
-  /// different (the map is actually invertable) or there are only a few
-  /// items with the same value.
-  /// Otherwise consider to use \c IterableValueMap, which is more
-  /// suitable and more efficient for such cases. It provides iterators
-  /// to traverse the items with the same associated value, but
-  /// it does not have \c InverseMap.
+  /// The values of the map can be accessed
+  /// with stl compatible forward iterator.
   ///
   /// This type is not reference map, so it cannot be modified with
@@ -1965,38 +1947,31 @@
     /// \brief Forward iterator for values.
     ///
-    /// This iterator is an STL compatible forward
+    /// This iterator is an stl compatible forward
     /// iterator on the values of the map. The values can
     /// be accessed in the <tt>[beginValue, endValue)</tt> range.
     /// They are considered with multiplicity, so each value is
     /// traversed for each item it is assigned to.
-    class ValueIt
+    class ValueIterator
       : public std::iterator<std::forward_iterator_tag, Value> {
       friend class CrossRefMap;
     private:
-      ValueIt(typename Container::const_iterator _it)
+      ValueIterator(typename Container::const_iterator _it)
         : it(_it) {}
     public:
 
-      /// Constructor
-      ValueIt() {}
-
-      /// \e
-      ValueIt& operator++() { ++it; return *this; }
-      /// \e
-      ValueIt operator++(int) {
-        ValueIt tmp(*this);
+      ValueIterator() {}
+
+      ValueIterator& operator++() { ++it; return *this; }
+      ValueIterator operator++(int) {
+        ValueIterator tmp(*this);
         operator++();
         return tmp;
       }
 
-      /// \e
       const Value& operator*() const { return it->first; }
-      /// \e
       const Value* operator->() const { return &(it->first); }
 
-      /// \e
-      bool operator==(ValueIt jt) const { return it == jt.it; }
-      /// \e
-      bool operator!=(ValueIt jt) const { return it != jt.it; }
+      bool operator==(ValueIterator jt) const { return it == jt.it; }
+      bool operator!=(ValueIterator jt) const { return it != jt.it; }
 
     private:
@@ -2004,25 +1979,22 @@
     };
 
-    /// Alias for \c ValueIt
-    typedef ValueIt ValueIterator;
-
     /// \brief Returns an iterator to the first value.
     ///
-    /// Returns an STL compatible iterator to the
+    /// Returns an stl compatible iterator to the
     /// first value of the map. The values of the
     /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
-    ValueIt beginValue() const {
-      return ValueIt(_inv_map.begin());
+    ValueIterator beginValue() const {
+      return ValueIterator(_inv_map.begin());
     }
 
     /// \brief Returns an iterator after the last value.
     ///
-    /// Returns an STL compatible iterator after the
+    /// Returns an stl compatible iterator after the
     /// last value of the map. The values of the
     /// map can be accessed in the <tt>[beginValue, endValue)</tt>
     /// range.
-    ValueIt endValue() const {
-      return ValueIt(_inv_map.end());
+    ValueIterator endValue() const {
+      return ValueIterator(_inv_map.end());
     }
 
@@ -2061,12 +2033,4 @@
       typename Container::const_iterator it = _inv_map.find(val);
       return it != _inv_map.end() ? it->second : INVALID;
-    }
-
-    /// \brief Returns the number of items with the given value.
-    ///
-    /// This function returns the number of items with the given value
-    /// associated with it.
-    int count(const Value &val) const {
-      return _inv_map.count(val);
     }
 
@@ -2120,10 +2084,8 @@
   public:
 
-    /// \brief The inverse map type of CrossRefMap.
-    ///
-    /// The inverse map type of CrossRefMap. The subscript operator gives
-    /// back an item by its value.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
-    /// \see inverse()
+    /// \brief The inverse map type.
+    ///
+    /// The inverse of this map. The subscript operator of the map
+    /// gives back the item that was last assigned to the value.
     class InverseMap {
     public:
@@ -2152,7 +2114,7 @@
     };
 
-    /// \brief Gives back the inverse of the map.
-    ///
-    /// Gives back the inverse of the CrossRefMap.
+    /// \brief It gives back the read-only inverse map.
+    ///
+    /// It gives back the read-only inverse map.
     InverseMap inverse() const {
       return InverseMap(*this);
@@ -2161,9 +2123,9 @@
   };
 
-  /// \brief Provides continuous and unique id for the
+  /// \brief Provides continuous and unique ID for the
   /// items of a graph.
   ///
   /// RangeIdMap provides a unique and continuous
-  /// id for each item of a given type (\c Node, \c Arc or
+  /// ID for each item of a given type (\c Node, \c Arc or
   /// \c Edge) in a graph. This id is
   ///  - \b unique: different items get different ids,
@@ -2176,5 +2138,5 @@
   /// the \c id() function of the graph or \ref IdMap.
   /// This map can be inverted with its member class \c InverseMap,
-  /// or with the \c operator()() member.
+  /// or with the \c operator() member.
   ///
   /// \tparam GR The graph type.
@@ -2304,14 +2266,14 @@
     }
 
-    /// \brief Gives back the \e range \e id of the item
-    ///
-    /// Gives back the \e range \e id of the item.
+    /// \brief Gives back the \e RangeId of the item
+    ///
+    /// Gives back the \e RangeId of the item.
     int operator[](const Item& item) const {
       return Map::operator[](item);
     }
 
-    /// \brief Gives back the item belonging to a \e range \e id
-    ///
-    /// Gives back the item belonging to the given \e range \e id.
+    /// \brief Gives back the item belonging to a \e RangeId
+    /// 
+    /// Gives back the item belonging to a \e RangeId.
     Item operator()(int id) const {
       return _inv_map[id];
@@ -2327,7 +2289,5 @@
     /// \brief The inverse map type of RangeIdMap.
     ///
-    /// The inverse map type of RangeIdMap. The subscript operator gives
-    /// back an item by its \e range \e id.
-    /// This type conforms to the \ref concepts::ReadMap "ReadMap" concept.
+    /// The inverse map type of RangeIdMap.
     class InverseMap {
     public:
@@ -2347,5 +2307,5 @@
       ///
       /// Subscript operator. It gives back the item
-      /// that the given \e range \e id currently belongs to.
+      /// that the descriptor currently belongs to.
       Value operator[](const Key& key) const {
         return _inverted(key);
@@ -2365,928 +2325,8 @@
     /// \brief Gives back the inverse of the map.
     ///
-    /// Gives back the inverse of the RangeIdMap.
+    /// Gives back the inverse of the map.
     const InverseMap inverse() const {
       return InverseMap(*this);
     }
-  };
-
-  /// \brief Returns a \c RangeIdMap class.
-  ///
-  /// This function just returns an \c RangeIdMap class.
-  /// \relates RangeIdMap
-  template <typename K, typename GR>
-  inline RangeIdMap<GR, K> rangeIdMap(const GR& graph) {
-    return RangeIdMap<GR, K>(graph);
-  }
-
-  /// \brief Dynamic iterable \c bool map.
-  ///
-  /// This class provides a special graph map type which can store a
-  /// \c bool value for graph items (\c Node, \c Arc or \c Edge).
-  /// For both \c true and \c false values it is possible to iterate on
-  /// the keys mapped to the value.
-  ///
-  /// This type is a reference map, so it can be modified with the
-  /// subscript operator.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IterableIntMap, IterableValueMap
-  /// \see CrossRefMap
-  template <typename GR, typename K>
-  class IterableBoolMap
-    : protected ItemSetTraits<GR, K>::template Map<int>::Type {
-  private:
-    typedef GR Graph;
-
-    typedef typename ItemSetTraits<GR, K>::ItemIt KeyIt;
-    typedef typename ItemSetTraits<GR, K>::template Map<int>::Type Parent;
-
-    std::vector<K> _array;
-    int _sep;
-
-  public:
-
-    /// Indicates that the map is reference map.
-    typedef True ReferenceMapTag;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef bool Value;
-    /// The const reference type.
-    typedef const Value& ConstReference;
-
-  private:
-
-    int position(const Key& key) const {
-      return Parent::operator[](key);
-    }
-
-  public:
-
-    /// \brief Reference to the value of the map.
-    ///
-    /// This class is similar to the \c bool type. It can be converted to
-    /// \c bool and it provides the same operators.
-    class Reference {
-      friend class IterableBoolMap;
-    private:
-      Reference(IterableBoolMap& map, const Key& key)
-        : _key(key), _map(map) {}
-    public:
-
-      Reference& operator=(const Reference& value) {
-        _map.set(_key, static_cast<bool>(value));
-         return *this;
-      }
-
-      operator bool() const {
-        return static_cast<const IterableBoolMap&>(_map)[_key];
-      }
-
-      Reference& operator=(bool value) {
-        _map.set(_key, value);
-        return *this;
-      }
-      Reference& operator&=(bool value) {
-        _map.set(_key, _map[_key] & value);
-        return *this;
-      }
-      Reference& operator|=(bool value) {
-        _map.set(_key, _map[_key] | value);
-        return *this;
-      }
-      Reference& operator^=(bool value) {
-        _map.set(_key, _map[_key] ^ value);
-        return *this;
-      }
-    private:
-      Key _key;
-      IterableBoolMap& _map;
-    };
-
-    /// \brief Constructor of the map with a default value.
-    ///
-    /// Constructor of the map with a default value.
-    explicit IterableBoolMap(const Graph& graph, bool def = false)
-      : Parent(graph) {
-      typename Parent::Notifier* nf = Parent::notifier();
-      Key it;
-      for (nf->first(it); it != INVALID; nf->next(it)) {
-        Parent::set(it, _array.size());
-        _array.push_back(it);
-      }
-      _sep = (def ? _array.size() : 0);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    bool operator[](const Key& key) const {
-      return position(key) < _sep;
-    }
-
-    /// \brief Subscript operator of the map.
-    ///
-    /// Subscript operator of the map.
-    Reference operator[](const Key& key) {
-      return Reference(*this, key);
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, bool value) {
-      int pos = position(key);
-      if (value) {
-        if (pos < _sep) return;
-        Key tmp = _array[_sep];
-        _array[_sep] = key;
-        Parent::set(key, _sep);
-        _array[pos] = tmp;
-        Parent::set(tmp, pos);
-        ++_sep;
-      } else {
-        if (pos >= _sep) return;
-        --_sep;
-        Key tmp = _array[_sep];
-        _array[_sep] = key;
-        Parent::set(key, _sep);
-        _array[pos] = tmp;
-        Parent::set(tmp, pos);
-      }
-    }
-
-    /// \brief Set all items.
-    ///
-    /// Set all items in the map.
-    /// \note Constant time operation.
-    void setAll(bool value) {
-      _sep = (value ? _array.size() : 0);
-    }
-
-    /// \brief Returns the number of the keys mapped to \c true.
-    ///
-    /// Returns the number of the keys mapped to \c true.
-    int trueNum() const {
-      return _sep;
-    }
-
-    /// \brief Returns the number of the keys mapped to \c false.
-    ///
-    /// Returns the number of the keys mapped to \c false.
-    int falseNum() const {
-      return _array.size() - _sep;
-    }
-
-    /// \brief Iterator for the keys mapped to \c true.
-    ///
-    /// Iterator for the keys mapped to \c true. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class TrueIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator.
-      ///
-      /// Creates an iterator. It iterates on the
-      /// keys mapped to \c true.
-      /// \param map The IterableBoolMap.
-      explicit TrueIt(const IterableBoolMap& map)
-        : Parent(map._sep > 0 ? map._array[map._sep - 1] : INVALID),
-          _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      TrueIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      TrueIt& operator++() {
-        int pos = _map->position(*this);
-        Parent::operator=(pos > 0 ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-    /// \brief Iterator for the keys mapped to \c false.
-    ///
-    /// Iterator for the keys mapped to \c false. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class FalseIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator.
-      ///
-      /// Creates an iterator. It iterates on the
-      /// keys mapped to \c false.
-      /// \param map The IterableBoolMap.
-      explicit FalseIt(const IterableBoolMap& map)
-        : Parent(map._sep < int(map._array.size()) ?
-                 map._array.back() : INVALID), _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      FalseIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      FalseIt& operator++() {
-        int pos = _map->position(*this);
-        Parent::operator=(pos > _map->_sep ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-    /// \brief Iterator for the keys mapped to a given value.
-    ///
-    /// Iterator for the keys mapped to a given value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the key type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid key, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys mapped to the given value.
-      /// \param map The IterableBoolMap.
-      /// \param value The value.
-      ItemIt(const IterableBoolMap& map, bool value)
-        : Parent(value ?
-                 (map._sep > 0 ?
-                  map._array[map._sep - 1] : INVALID) :
-                 (map._sep < int(map._array.size()) ?
-                  map._array.back() : INVALID)), _map(&map) {}
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ItemIt& operator++() {
-        int pos = _map->position(*this);
-        int _sep = pos >= _map->_sep ? _map->_sep : 0;
-        Parent::operator=(pos > _sep ? _map->_array[pos - 1] : INVALID);
-        return *this;
-      }
-
-    private:
-      const IterableBoolMap* _map;
-    };
-
-  protected:
-
-    virtual void add(const Key& key) {
-      Parent::add(key);
-      Parent::set(key, _array.size());
-      _array.push_back(key);
-    }
-
-    virtual void add(const std::vector<Key>& keys) {
-      Parent::add(keys);
-      for (int i = 0; i < int(keys.size()); ++i) {
-        Parent::set(keys[i], _array.size());
-        _array.push_back(keys[i]);
-      }
-    }
-
-    virtual void erase(const Key& key) {
-      int pos = position(key);
-      if (pos < _sep) {
-        --_sep;
-        Parent::set(_array[_sep], pos);
-        _array[pos] = _array[_sep];
-        Parent::set(_array.back(), _sep);
-        _array[_sep] = _array.back();
-        _array.pop_back();
-      } else {
-        Parent::set(_array.back(), pos);
-        _array[pos] = _array.back();
-        _array.pop_back();
-      }
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        int pos = position(keys[i]);
-        if (pos < _sep) {
-          --_sep;
-          Parent::set(_array[_sep], pos);
-          _array[pos] = _array[_sep];
-          Parent::set(_array.back(), _sep);
-          _array[_sep] = _array.back();
-          _array.pop_back();
-        } else {
-          Parent::set(_array.back(), pos);
-          _array[pos] = _array.back();
-          _array.pop_back();
-        }
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void build() {
-      Parent::build();
-      typename Parent::Notifier* nf = Parent::notifier();
-      Key it;
-      for (nf->first(it); it != INVALID; nf->next(it)) {
-        Parent::set(it, _array.size());
-        _array.push_back(it);
-      }
-      _sep = 0;
-    }
-
-    virtual void clear() {
-      _array.clear();
-      _sep = 0;
-      Parent::clear();
-    }
-
-  };
-
-
-  namespace _maps_bits {
-    template <typename Item>
-    struct IterableIntMapNode {
-      IterableIntMapNode() : value(-1) {}
-      IterableIntMapNode(int _value) : value(_value) {}
-      Item prev, next;
-      int value;
-    };
-  }
-
-  /// \brief Dynamic iterable integer map.
-  ///
-  /// This class provides a special graph map type which can store an
-  /// integer value for graph items (\c Node, \c Arc or \c Edge).
-  /// For each non-negative value it is possible to iterate on the keys
-  /// mapped to the value.
-  ///
-  /// This map is intended to be used with small integer values, for which
-  /// it is efficient, and supports iteration only for non-negative values.
-  /// If you need large values and/or iteration for negative integers,
-  /// consider to use \ref IterableValueMap instead.
-  ///
-  /// This type is a reference map, so it can be modified with the
-  /// subscript operator.
-  ///
-  /// \note The size of the data structure depends on the largest
-  /// value in the map.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  ///
-  /// \see IterableBoolMap, IterableValueMap
-  /// \see CrossRefMap
-  template <typename GR, typename K>
-  class IterableIntMap
-    : protected ItemSetTraits<GR, K>::
-        template Map<_maps_bits::IterableIntMapNode<K> >::Type {
-  public:
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<_maps_bits::IterableIntMapNode<K> >::Type Parent;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef int Value;
-    /// The graph type
-    typedef GR Graph;
-
-    /// \brief Constructor of the map.
-    ///
-    /// Constructor of the map. It sets all values to -1.
-    explicit IterableIntMap(const Graph& graph)
-      : Parent(graph) {}
-
-    /// \brief Constructor of the map with a given value.
-    ///
-    /// Constructor of the map with a given value.
-    explicit IterableIntMap(const Graph& graph, int value)
-      : Parent(graph, _maps_bits::IterableIntMapNode<K>(value)) {
-      if (value >= 0) {
-        for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-          lace(it);
-        }
-      }
-    }
-
-  private:
-
-    void unlace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.value < 0) return;
-      if (node.prev != INVALID) {
-        Parent::operator[](node.prev).next = node.next;
-      } else {
-        _first[node.value] = node.next;
-      }
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = node.prev;
-      }
-      while (!_first.empty() && _first.back() == INVALID) {
-        _first.pop_back();
-      }
-    }
-
-    void lace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.value < 0) return;
-      if (node.value >= int(_first.size())) {
-        _first.resize(node.value + 1, INVALID);
-      }
-      node.prev = INVALID;
-      node.next = _first[node.value];
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = key;
-      }
-      _first[node.value] = key;
-    }
-
-  public:
-
-    /// Indicates that the map is reference map.
-    typedef True ReferenceMapTag;
-
-    /// \brief Reference to the value of the map.
-    ///
-    /// This class is similar to the \c int type. It can
-    /// be converted to \c int and it has the same operators.
-    class Reference {
-      friend class IterableIntMap;
-    private:
-      Reference(IterableIntMap& map, const Key& key)
-        : _key(key), _map(map) {}
-    public:
-
-      Reference& operator=(const Reference& value) {
-        _map.set(_key, static_cast<const int&>(value));
-         return *this;
-      }
-
-      operator const int&() const {
-        return static_cast<const IterableIntMap&>(_map)[_key];
-      }
-
-      Reference& operator=(int value) {
-        _map.set(_key, value);
-        return *this;
-      }
-      Reference& operator++() {
-        _map.set(_key, _map[_key] + 1);
-        return *this;
-      }
-      int operator++(int) {
-        int value = _map[_key];
-        _map.set(_key, value + 1);
-        return value;
-      }
-      Reference& operator--() {
-        _map.set(_key, _map[_key] - 1);
-        return *this;
-      }
-      int operator--(int) {
-        int value = _map[_key];
-        _map.set(_key, value - 1);
-        return value;
-      }
-      Reference& operator+=(int value) {
-        _map.set(_key, _map[_key] + value);
-        return *this;
-      }
-      Reference& operator-=(int value) {
-        _map.set(_key, _map[_key] - value);
-        return *this;
-      }
-      Reference& operator*=(int value) {
-        _map.set(_key, _map[_key] * value);
-        return *this;
-      }
-      Reference& operator/=(int value) {
-        _map.set(_key, _map[_key] / value);
-        return *this;
-      }
-      Reference& operator%=(int value) {
-        _map.set(_key, _map[_key] % value);
-        return *this;
-      }
-      Reference& operator&=(int value) {
-        _map.set(_key, _map[_key] & value);
-        return *this;
-      }
-      Reference& operator|=(int value) {
-        _map.set(_key, _map[_key] | value);
-        return *this;
-      }
-      Reference& operator^=(int value) {
-        _map.set(_key, _map[_key] ^ value);
-        return *this;
-      }
-      Reference& operator<<=(int value) {
-        _map.set(_key, _map[_key] << value);
-        return *this;
-      }
-      Reference& operator>>=(int value) {
-        _map.set(_key, _map[_key] >> value);
-        return *this;
-      }
-
-    private:
-      Key _key;
-      IterableIntMap& _map;
-    };
-
-    /// The const reference type.
-    typedef const Value& ConstReference;
-
-    /// \brief Gives back the maximal value plus one.
-    ///
-    /// Gives back the maximal value plus one.
-    int size() const {
-      return _first.size();
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, const Value& value) {
-      unlace(key);
-      Parent::operator[](key).value = value;
-      lace(key);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    const Value& operator[](const Key& key) const {
-      return Parent::operator[](key).value;
-    }
-
-    /// \brief Subscript operator of the map.
-    ///
-    /// Subscript operator of the map.
-    Reference operator[](const Key& key) {
-      return Reference(*this, key);
-    }
-
-    /// \brief Iterator for the keys with the same value.
-    ///
-    /// Iterator for the keys with the same value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the item type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid item, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys mapped to the given value.
-      /// \param map The IterableIntMap.
-      /// \param value The value.
-      ItemIt(const IterableIntMap& map, int value) : _map(&map) {
-        if (value < 0 || value >= int(_map->_first.size())) {
-          Parent::operator=(INVALID);
-        } else {
-          Parent::operator=(_map->_first[value]);
-        }
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment operator.
-      ItemIt& operator++() {
-        Parent::operator=(_map->IterableIntMap::Parent::
-                          operator[](static_cast<Parent&>(*this)).next);
-        return *this;
-      }
-
-    private:
-      const IterableIntMap* _map;
-    };
-
-  protected:
-
-    virtual void erase(const Key& key) {
-      unlace(key);
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        unlace(keys[i]);
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void clear() {
-      _first.clear();
-      Parent::clear();
-    }
-
-  private:
-    std::vector<Key> _first;
-  };
-
-  namespace _maps_bits {
-    template <typename Item, typename Value>
-    struct IterableValueMapNode {
-      IterableValueMapNode(Value _value = Value()) : value(_value) {}
-      Item prev, next;
-      Value value;
-    };
-  }
-
-  /// \brief Dynamic iterable map for comparable values.
-  ///
-  /// This class provides a special graph map type which can store a
-  /// comparable value for graph items (\c Node, \c Arc or \c Edge).
-  /// For each value it is possible to iterate on the keys mapped to
-  /// the value (\c ItemIt), and the values of the map can be accessed
-  /// with an STL compatible forward iterator (\c ValueIt).
-  /// The map stores a linked list for each value, which contains
-  /// the items mapped to the value, and the used values are stored
-  /// in balanced binary tree (\c std::map).
-  ///
-  /// \ref IterableBoolMap and \ref IterableIntMap are similar classes
-  /// specialized for \c bool and \c int values, respectively.
-  ///
-  /// This type is not reference map, so it cannot be modified with
-  /// the subscript operator.
-  ///
-  /// \tparam GR The graph type.
-  /// \tparam K The key type of the map (\c GR::Node, \c GR::Arc or
-  /// \c GR::Edge).
-  /// \tparam V The value type of the map. It can be any comparable
-  /// value type.
-  ///
-  /// \see IterableBoolMap, IterableIntMap
-  /// \see CrossRefMap
-  template <typename GR, typename K, typename V>
-  class IterableValueMap
-    : protected ItemSetTraits<GR, K>::
-        template Map<_maps_bits::IterableValueMapNode<K, V> >::Type {
-  public:
-    typedef typename ItemSetTraits<GR, K>::
-      template Map<_maps_bits::IterableValueMapNode<K, V> >::Type Parent;
-
-    /// The key type
-    typedef K Key;
-    /// The value type
-    typedef V Value;
-    /// The graph type
-    typedef GR Graph;
-
-  public:
-
-    /// \brief Constructor of the map with a given value.
-    ///
-    /// Constructor of the map with a given value.
-    explicit IterableValueMap(const Graph& graph,
-                              const Value& value = Value())
-      : Parent(graph, _maps_bits::IterableValueMapNode<K, V>(value)) {
-      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-        lace(it);
-      }
-    }
-
-  protected:
-
-    void unlace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      if (node.prev != INVALID) {
-        Parent::operator[](node.prev).next = node.next;
-      } else {
-        if (node.next != INVALID) {
-          _first[node.value] = node.next;
-        } else {
-          _first.erase(node.value);
-        }
-      }
-      if (node.next != INVALID) {
-        Parent::operator[](node.next).prev = node.prev;
-      }
-    }
-
-    void lace(const Key& key) {
-      typename Parent::Value& node = Parent::operator[](key);
-      typename std::map<Value, Key>::iterator it = _first.find(node.value);
-      if (it == _first.end()) {
-        node.prev = node.next = INVALID;
-        _first.insert(std::make_pair(node.value, key));
-      } else {
-        node.prev = INVALID;
-        node.next = it->second;
-        if (node.next != INVALID) {
-          Parent::operator[](node.next).prev = key;
-        }
-        it->second = key;
-      }
-    }
-
-  public:
-
-    /// \brief Forward iterator for values.
-    ///
-    /// This iterator is an STL compatible forward
-    /// iterator on the values of the map. The values can
-    /// be accessed in the <tt>[beginValue, endValue)</tt> range.
-    class ValueIt
-      : public std::iterator<std::forward_iterator_tag, Value> {
-      friend class IterableValueMap;
-    private:
-      ValueIt(typename std::map<Value, Key>::const_iterator _it)
-        : it(_it) {}
-    public:
-
-      /// Constructor
-      ValueIt() {}
-
-      /// \e
-      ValueIt& operator++() { ++it; return *this; }
-      /// \e
-      ValueIt operator++(int) {
-        ValueIt tmp(*this);
-        operator++();
-        return tmp;
-      }
-
-      /// \e
-      const Value& operator*() const { return it->first; }
-      /// \e
-      const Value* operator->() const { return &(it->first); }
-
-      /// \e
-      bool operator==(ValueIt jt) const { return it == jt.it; }
-      /// \e
-      bool operator!=(ValueIt jt) const { return it != jt.it; }
-
-    private:
-      typename std::map<Value, Key>::const_iterator it;
-    };
-
-    /// \brief Returns an iterator to the first value.
-    ///
-    /// Returns an STL compatible iterator to the
-    /// first value of the map. The values of the
-    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
-    /// range.
-    ValueIt beginValue() const {
-      return ValueIt(_first.begin());
-    }
-
-    /// \brief Returns an iterator after the last value.
-    ///
-    /// Returns an STL compatible iterator after the
-    /// last value of the map. The values of the
-    /// map can be accessed in the <tt>[beginValue, endValue)</tt>
-    /// range.
-    ValueIt endValue() const {
-      return ValueIt(_first.end());
-    }
-
-    /// \brief Set operation of the map.
-    ///
-    /// Set operation of the map.
-    void set(const Key& key, const Value& value) {
-      unlace(key);
-      Parent::operator[](key).value = value;
-      lace(key);
-    }
-
-    /// \brief Const subscript operator of the map.
-    ///
-    /// Const subscript operator of the map.
-    const Value& operator[](const Key& key) const {
-      return Parent::operator[](key).value;
-    }
-
-    /// \brief Iterator for the keys with the same value.
-    ///
-    /// Iterator for the keys with the same value. It works
-    /// like a graph item iterator, it can be converted to
-    /// the item type of the map, incremented with \c ++ operator, and
-    /// if the iterator leaves the last valid item, it will be equal to
-    /// \c INVALID.
-    class ItemIt : public Key {
-    public:
-      typedef Key Parent;
-
-      /// \brief Invalid constructor \& conversion.
-      ///
-      /// This constructor initializes the iterator to be invalid.
-      /// \sa Invalid for more details.
-      ItemIt(Invalid) : Parent(INVALID), _map(0) {}
-
-      /// \brief Creates an iterator with a value.
-      ///
-      /// Creates an iterator with a value. It iterates on the
-      /// keys which have the given value.
-      /// \param map The IterableValueMap
-      /// \param value The value
-      ItemIt(const IterableValueMap& map, const Value& value) : _map(&map) {
-        typename std::map<Value, Key>::const_iterator it =
-          map._first.find(value);
-        if (it == map._first.end()) {
-          Parent::operator=(INVALID);
-        } else {
-          Parent::operator=(it->second);
-        }
-      }
-
-      /// \brief Increment operator.
-      ///
-      /// Increment Operator.
-      ItemIt& operator++() {
-        Parent::operator=(_map->IterableValueMap::Parent::
-                          operator[](static_cast<Parent&>(*this)).next);
-        return *this;
-      }
-
-
-    private:
-      const IterableValueMap* _map;
-    };
-
-  protected:
-
-    virtual void add(const Key& key) {
-      Parent::add(key);
-      lace(key);
-    }
-
-    virtual void add(const std::vector<Key>& keys) {
-      Parent::add(keys);
-      for (int i = 0; i < int(keys.size()); ++i) {
-        lace(keys[i]);
-      }
-    }
-
-    virtual void erase(const Key& key) {
-      unlace(key);
-      Parent::erase(key);
-    }
-
-    virtual void erase(const std::vector<Key>& keys) {
-      for (int i = 0; i < int(keys.size()); ++i) {
-        unlace(keys[i]);
-      }
-      Parent::erase(keys);
-    }
-
-    virtual void build() {
-      Parent::build();
-      for (typename Parent::ItemIt it(*this); it != INVALID; ++it) {
-        lace(it);
-      }
-    }
-
-    virtual void clear() {
-      _first.clear();
-      Parent::clear();
-    }
-
-  private:
-    std::map<Value, Key> _first;
   };
 
@@ -3301,7 +2341,7 @@
   public:
 
-    /// The key type (the \c Arc type of the digraph).
+    ///\e
     typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
+    ///\e
     typedef typename GR::Node Value;
 
@@ -3342,7 +2382,7 @@
   public:
 
-    /// The key type (the \c Arc type of the digraph).
+    ///\e
     typedef typename GR::Arc Key;
-    /// The value type (the \c Node type of the digraph).
+    ///\e
     typedef typename GR::Node Value;
 
@@ -3384,8 +2424,6 @@
   public:
 
-    /// The key type (the \c Edge type of the digraph).
+    typedef typename GR::Arc Value;
     typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
 
     /// \brief Constructor
@@ -3426,8 +2464,6 @@
   public:
 
-    /// The key type (the \c Edge type of the digraph).
+    typedef typename GR::Arc Value;
     typedef typename GR::Edge Key;
-    /// The value type (the \c Arc type of the digraph).
-    typedef typename GR::Arc Value;
 
     /// \brief Constructor
@@ -3464,8 +2500,8 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of InDegMap is not guarantied if these additional
-  /// features are used. For example, the functions
+  /// features are used. For example the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
@@ -3480,5 +2516,5 @@
 
   public:
-
+    
     /// The graph type of InDegMap
     typedef GR Graph;
@@ -3594,8 +2630,8 @@
   /// whenever the digraph changes.
   ///
-  /// \warning Besides \c addNode() and \c addArc(), a digraph structure
+  /// \warning Besides \c addNode() and \c addArc(), a digraph structure 
   /// may provide alternative ways to modify the digraph.
   /// The correct behavior of OutDegMap is not guarantied if these additional
-  /// features are used. For example, the functions
+  /// features are used. For example the functions
   /// \ref ListDigraph::changeSource() "changeSource()",
   /// \ref ListDigraph::changeTarget() "changeTarget()" and
@@ -3765,291 +2801,4 @@
   }
 
-
-  /// \brief Copy the values of a graph map to another map.
-  ///
-  /// This function copies the values of a graph map to another graph map.
-  /// \c To::Key must be equal or convertible to \c From::Key and
-  /// \c From::Value must be equal or convertible to \c To::Value.
-  ///
-  /// For example, an edge map of \c int value type can be copied to
-  /// an arc map of \c double value type in an undirected graph, but
-  /// an arc map cannot be copied to an edge map.
-  /// Note that even a \ref ConstMap can be copied to a standard graph map,
-  /// but \ref mapFill() can also be used for this purpose.
-  ///
-  /// \param gr The graph for which the maps are defined.
-  /// \param from The map from which the values have to be copied.
-  /// It must conform to the \ref concepts::ReadMap "ReadMap" concept.
-  /// \param to The map to which the values have to be copied.
-  /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-  template <typename GR, typename From, typename To>
-  void mapCopy(const GR& gr, const From& from, To& to) {
-    typedef typename To::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      to.set(it, from[it]);
-    }
-  }
-
-  /// \brief Compare two graph maps.
-  ///
-  /// This function compares the values of two graph maps. It returns
-  /// \c true if the maps assign the same value for all items in the graph.
-  /// The \c Key type of the maps (\c Node, \c Arc or \c Edge) must be equal
-  /// and their \c Value types must be comparable using \c %operator==().
-  ///
-  /// \param gr The graph for which the maps are defined.
-  /// \param map1 The first map.
-  /// \param map2 The second map.
-  template <typename GR, typename Map1, typename Map2>
-  bool mapCompare(const GR& gr, const Map1& map1, const Map2& map2) {
-    typedef typename Map2::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (!(map1[it] == map2[it])) return false;
-    }
-    return true;
-  }
-
-  /// \brief Return an item having minimum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// minimum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Key mapMin(const GR& gr, const Map& map) {
-    return mapMin(gr, map, std::less<typename Map::Value>());
-  }
-
-  /// \brief Return an item having minimum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// minimum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Key mapMin(const GR& gr, const Map& map, const Comp& comp) {
-    typedef typename Map::Key Item;
-    typedef typename Map::Value Value;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    ItemIt min_item(gr);
-    if (min_item == INVALID) return INVALID;
-    Value min = map[min_item];
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (comp(map[it], min)) {
-        min = map[it];
-        min_item = it;
-      }
-    }
-    return min_item;
-  }
-
-  /// \brief Return an item having maximum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// maximum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Key mapMax(const GR& gr, const Map& map) {
-    return mapMax(gr, map, std::less<typename Map::Value>());
-  }
-
-  /// \brief Return an item having maximum value of a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// maximum value of the given graph map.
-  /// If the item set is empty, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Key mapMax(const GR& gr, const Map& map, const Comp& comp) {
-    typedef typename Map::Key Item;
-    typedef typename Map::Value Value;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    ItemIt max_item(gr);
-    if (max_item == INVALID) return INVALID;
-    Value max = map[max_item];
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (comp(max, map[it])) {
-        max = map[it];
-        max_item = it;
-      }
-    }
-    return max_item;
-  }
-
-  /// \brief Return the minimum value of a graph map.
-  ///
-  /// This function returns the minimum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Value mapMinValue(const GR& gr, const Map& map) {
-    return map[mapMin(gr, map, std::less<typename Map::Value>())];
-  }
-
-  /// \brief Return the minimum value of a graph map.
-  ///
-  /// This function returns the minimum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Value
-  mapMinValue(const GR& gr, const Map& map, const Comp& comp) {
-    return map[mapMin(gr, map, comp)];
-  }
-
-  /// \brief Return the maximum value of a graph map.
-  ///
-  /// This function returns the maximum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  template <typename GR, typename Map>
-  typename Map::Value mapMaxValue(const GR& gr, const Map& map) {
-    return map[mapMax(gr, map, std::less<typename Map::Value>())];
-  }
-
-  /// \brief Return the maximum value of a graph map.
-  ///
-  /// This function returns the maximum value of the given graph map.
-  /// The corresponding item set of the graph must not be empty.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param comp Comparison function object.
-  template <typename GR, typename Map, typename Comp>
-  typename Map::Value
-  mapMaxValue(const GR& gr, const Map& map, const Comp& comp) {
-    return map[mapMax(gr, map, comp)];
-  }
-
-  /// \brief Return an item having a specified value in a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// the specified assigned value in the given graph map.
-  /// If no such item exists, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param val The value that have to be found.
-  template <typename GR, typename Map>
-  typename Map::Key
-  mapFind(const GR& gr, const Map& map, const typename Map::Value& val) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (map[it] == val) return it;
-    }
-    return INVALID;
-  }
-
-  /// \brief Return an item having value for which a certain predicate is
-  /// true in a graph map.
-  ///
-  /// This function returns an item (\c Node, \c Arc or \c Edge) having
-  /// such assigned value for which the specified predicate is true
-  /// in the given graph map.
-  /// If no such item exists, it returns \c INVALID.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param pred The predicate function object.
-  template <typename GR, typename Map, typename Pred>
-  typename Map::Key
-  mapFindIf(const GR& gr, const Map& map, const Pred& pred) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (pred(map[it])) return it;
-    }
-    return INVALID;
-  }
-
-  /// \brief Return the number of items having a specified value in a
-  /// graph map.
-  ///
-  /// This function returns the number of items (\c Node, \c Arc or \c Edge)
-  /// having the specified assigned value in the given graph map.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param val The value that have to be counted.
-  template <typename GR, typename Map>
-  int mapCount(const GR& gr, const Map& map, const typename Map::Value& val) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    int cnt = 0;
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (map[it] == val) ++cnt;
-    }
-    return cnt;
-  }
-
-  /// \brief Return the number of items having values for which a certain
-  /// predicate is true in a graph map.
-  ///
-  /// This function returns the number of items (\c Node, \c Arc or \c Edge)
-  /// having such assigned values for which the specified predicate is true
-  /// in the given graph map.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map.
-  /// \param pred The predicate function object.
-  template <typename GR, typename Map, typename Pred>
-  int mapCountIf(const GR& gr, const Map& map, const Pred& pred) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    int cnt = 0;
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      if (pred(map[it])) ++cnt;
-    }
-    return cnt;
-  }
-
-  /// \brief Fill a graph map with a certain value.
-  ///
-  /// This function sets the specified value for all items (\c Node,
-  /// \c Arc or \c Edge) in the given graph map.
-  ///
-  /// \param gr The graph for which the map is defined.
-  /// \param map The graph map. It must conform to the
-  /// \ref concepts::WriteMap "WriteMap" concept.
-  /// \param val The value.
-  template <typename GR, typename Map>
-  void mapFill(const GR& gr, Map& map, const typename Map::Value& val) {
-    typedef typename Map::Key Item;
-    typedef typename ItemSetTraits<GR, Item>::ItemIt ItemIt;
-
-    for (ItemIt it(gr); it != INVALID; ++it) {
-      map.set(it, val);
-    }
-  }
-
   /// @}
 }
Index: lemon/matching.h
===================================================================
--- lemon/matching.h	(revision 877)
+++ lemon/matching.h	(revision 867)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -17,6 +17,6 @@
  */
 
-#ifndef LEMON_MATCHING_H
-#define LEMON_MATCHING_H
+#ifndef LEMON_MAX_MATCHING_H
+#define LEMON_MAX_MATCHING_H
 
 #include <vector>
@@ -29,5 +29,4 @@
 #include <lemon/bin_heap.h>
 #include <lemon/maps.h>
-#include <lemon/fractional_matching.h>
 
 ///\ingroup matching
@@ -43,5 +42,5 @@
   /// This class implements Edmonds' alternating forest matching algorithm
   /// for finding a maximum cardinality matching in a general undirected graph.
-  /// It can be started from an arbitrary initial matching
+  /// It can be started from an arbitrary initial matching 
   /// (the default is the empty one).
   ///
@@ -71,9 +70,9 @@
     ///\brief Status constants for Gallai-Edmonds decomposition.
     ///
-    ///These constants are used for indicating the Gallai-Edmonds
+    ///These constants are used for indicating the Gallai-Edmonds 
     ///decomposition of a graph. The nodes with status \c EVEN (or \c D)
     ///induce a subgraph with factor-critical components, the nodes with
     ///status \c ODD (or \c A) form the canonical barrier, and the nodes
-    ///with status \c MATCHED (or \c C) induce a subgraph having a
+    ///with status \c MATCHED (or \c C) induce a subgraph having a 
     ///perfect matching.
     enum Status {
@@ -514,5 +513,5 @@
     }
 
-    /// \brief Start Edmonds' algorithm with a heuristic improvement
+    /// \brief Start Edmonds' algorithm with a heuristic improvement 
     /// for dense graphs
     ///
@@ -536,6 +535,6 @@
     /// \brief Run Edmonds' algorithm
     ///
-    /// This function runs Edmonds' algorithm. An additional heuristic of
-    /// postponing shrinks is used for relatively dense graphs
+    /// This function runs Edmonds' algorithm. An additional heuristic of 
+    /// postponing shrinks is used for relatively dense graphs 
     /// (for which <tt>m>=2*n</tt> holds).
     void run() {
@@ -558,5 +557,5 @@
     /// \brief Return the size (cardinality) of the matching.
     ///
-    /// This function returns the size (cardinality) of the current matching.
+    /// This function returns the size (cardinality) of the current matching. 
     /// After run() it returns the size of the maximum matching in the graph.
     int matchingSize() const {
@@ -572,5 +571,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the current
+    /// This function returns \c true if the given edge is in the current 
     /// matching.
     bool matching(const Edge& edge) const {
@@ -581,5 +580,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the current matching or \c INVALID if the node is
+    /// given node in the current matching or \c INVALID if the node is 
     /// not covered by the matching.
     Arc matching(const Node& n) const {
@@ -597,5 +596,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the current
+    /// This function returns the mate of the given node in the current 
     /// matching or \c INVALID if the node is not covered by the matching.
     Node mate(const Node& n) const {
@@ -607,5 +606,5 @@
 
     /// \name Dual Solution
-    /// Functions to get the dual solution, i.e. the Gallai-Edmonds
+    /// Functions to get the dual solution, i.e. the Gallai-Edmonds 
     /// decomposition.
 
@@ -650,6 +649,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted matching problem is to find a subset of the
-  /// edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted matching problem is to find a subset of the 
+  /// edges in an undirected graph with maximum overall weight for which 
   /// each node has at most one incident edge.
   /// It can be formulated with the following linear program.
@@ -675,14 +674,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -747,5 +746,5 @@
 
     enum Status {
-      EVEN = -1, MATCHED = 0, ODD = 1
+      EVEN = -1, MATCHED = 0, ODD = 1, UNMATCHED = -2
     };
 
@@ -799,8 +798,4 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedFractionalMatching<Graph, WeightMap> FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -869,4 +864,7 @@
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -944,5 +942,205 @@
               _delta3->push(e, rw / 2);
             }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
           } else {
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              if ((*_node_data)[vi].heap[it->second] > rw) {
+                (*_node_data)[vi].heap.replace(it->second, e);
+                (*_node_data)[vi].heap.decrease(e, rw);
+                it->second = e;
+              }
+            } else {
+              (*_node_data)[vi].heap.push(e, rw);
+              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
+            }
+
+            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
+              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_delta2->state(vb) != _delta2->IN_HEAP) {
+                  _delta2->push(vb, _blossom_set->classPrio(vb) -
+                               (*_blossom_data)[vb].offset);
+                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset){
+                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+      (*_blossom_data)[blossom].offset = 0;
+    }
+
+    void matchedToOdd(int blossom) {
+      if (_delta2->state(blossom) == _delta2->IN_HEAP) {
+        _delta2->erase(blossom);
+      }
+      (*_blossom_data)[blossom].offset += _delta_sum;
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
+                     (*_blossom_data)[blossom].offset);
+      }
+    }
+
+    void evenToMatched(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+        (*_node_data)[ni].pot -= _delta_sum;
+
+        _delta1->erase(n);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if (vb == blossom) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else if ((*_blossom_data)[vb].status == EVEN) {
+
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+
+            int vt = _tree_set->find(vb);
+
+            if (vt != tree) {
+
+              Arc r = _graph.oppositeArc(e);
+
+              typename std::map<int, Arc>::iterator it =
+                (*_node_data)[ni].heap_index.find(vt);
+
+              if (it != (*_node_data)[ni].heap_index.end()) {
+                if ((*_node_data)[ni].heap[it->second] > rw) {
+                  (*_node_data)[ni].heap.replace(it->second, r);
+                  (*_node_data)[ni].heap.decrease(r, rw);
+                  it->second = r;
+                }
+              } else {
+                (*_node_data)[ni].heap.push(r, rw);
+                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+              }
+
+              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                               (*_blossom_data)[blossom].offset);
+                } else if ((*_delta2)[blossom] >
+                           _blossom_set->classPrio(blossom) -
+                           (*_blossom_data)[blossom].offset){
+                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                   (*_blossom_data)[blossom].offset);
+                }
+              }
+            }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
+          } else {
+
+            typename std::map<int, Arc>::iterator it =
+              (*_node_data)[vi].heap_index.find(tree);
+
+            if (it != (*_node_data)[vi].heap_index.end()) {
+              (*_node_data)[vi].heap.erase(it->second);
+              (*_node_data)[vi].heap_index.erase(it);
+              if ((*_node_data)[vi].heap.empty()) {
+                _blossom_set->increase(v, std::numeric_limits<Value>::max());
+              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
+                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
+              }
+
+              if ((*_blossom_data)[vb].status == MATCHED) {
+                if (_blossom_set->classPrio(vb) ==
+                    std::numeric_limits<Value>::max()) {
+                  _delta2->erase(vb);
+                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
+                           (*_blossom_data)[vb].offset) {
+                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
+                                   (*_blossom_data)[vb].offset);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+
+    void oddToMatched(int blossom) {
+      (*_blossom_data)[blossom].offset -= _delta_sum;
+
+      if (_blossom_set->classPrio(blossom) !=
+          std::numeric_limits<Value>::max()) {
+        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                       (*_blossom_data)[blossom].offset);
+      }
+
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+      }
+    }
+
+    void oddToEven(int blossom, int tree) {
+      if (!_blossom_set->trivial(blossom)) {
+        _delta4->erase(blossom);
+        (*_blossom_data)[blossom].pot -=
+          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
+      }
+
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+        (*_node_data)[ni].pot +=
+          2 * _delta_sum - (*_blossom_data)[blossom].offset;
+
+        _delta1->push(n, (*_node_data)[ni].pot);
+
+        for (InArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.source(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
+              _delta3->push(e, rw / 2);
+            }
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          } else {
+
             typename std::map<int, Arc>::iterator it =
               (*_node_data)[vi].heap_index.find(tree);
@@ -979,18 +1177,8 @@
     }
 
-    void matchedToOdd(int blossom) {
+
+    void matchedToUnmatched(int blossom) {
       if (_delta2->state(blossom) == _delta2->IN_HEAP) {
         _delta2->erase(blossom);
-      }
-      (*_blossom_data)[blossom].offset += _delta_sum;
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->push(blossom, (*_blossom_data)[blossom].pot / 2 +
-                      (*_blossom_data)[blossom].offset);
-      }
-    }
-
-    void evenToMatched(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        (*_blossom_data)[blossom].pot += 2 * _delta_sum;
       }
 
@@ -998,7 +1186,31 @@
            n != INVALID; ++n) {
         int ni = (*_node_index)[n];
-        (*_node_data)[ni].pot -= _delta_sum;
-
-        _delta1->erase(n);
+
+        _blossom_set->increase(n, std::numeric_limits<Value>::max());
+
+        (*_node_data)[ni].heap.clear();
+        (*_node_data)[ni].heap_index.clear();
+
+        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
+          Node v = _graph.target(e);
+          int vb = _blossom_set->find(v);
+          int vi = (*_node_index)[v];
+
+          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
+            dualScale * _weight[e];
+
+          if ((*_blossom_data)[vb].status == EVEN) {
+            if (_delta3->state(e) != _delta3->IN_HEAP) {
+              _delta3->push(e, rw);
+            }
+          }
+        }
+      }
+    }
+
+    void unmatchedToMatched(int blossom) {
+      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
+           n != INVALID; ++n) {
+        int ni = (*_node_index)[n];
 
         for (InArcIt e(_graph, n); e != INVALID; ++e) {
@@ -1022,146 +1234,40 @@
             int vt = _tree_set->find(vb);
 
-            if (vt != tree) {
-
-              Arc r = _graph.oppositeArc(e);
-
-              typename std::map<int, Arc>::iterator it =
-                (*_node_data)[ni].heap_index.find(vt);
-
-              if (it != (*_node_data)[ni].heap_index.end()) {
-                if ((*_node_data)[ni].heap[it->second] > rw) {
-                  (*_node_data)[ni].heap.replace(it->second, r);
-                  (*_node_data)[ni].heap.decrease(r, rw);
-                  it->second = r;
-                }
-              } else {
-                (*_node_data)[ni].heap.push(r, rw);
-                (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
-              }
-
-              if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
-                _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-
-                if (_delta2->state(blossom) != _delta2->IN_HEAP) {
-                  _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                               (*_blossom_data)[blossom].offset);
-                } else if ((*_delta2)[blossom] >
-                           _blossom_set->classPrio(blossom) -
-                           (*_blossom_data)[blossom].offset){
-                  _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
-                                   (*_blossom_data)[blossom].offset);
-                }
-              }
-            }
-          } else {
+            Arc r = _graph.oppositeArc(e);
 
             typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              (*_node_data)[vi].heap.erase(it->second);
-              (*_node_data)[vi].heap_index.erase(it);
-              if ((*_node_data)[vi].heap.empty()) {
-                _blossom_set->increase(v, std::numeric_limits<Value>::max());
-              } else if ((*_blossom_set)[v] < (*_node_data)[vi].heap.prio()) {
-                _blossom_set->increase(v, (*_node_data)[vi].heap.prio());
-              }
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_blossom_set->classPrio(vb) ==
-                    std::numeric_limits<Value>::max()) {
-                  _delta2->erase(vb);
-                } else if ((*_delta2)[vb] < _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->increase(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-
-    void oddToMatched(int blossom) {
-      (*_blossom_data)[blossom].offset -= _delta_sum;
-
-      if (_blossom_set->classPrio(blossom) !=
-          std::numeric_limits<Value>::max()) {
-        _delta2->push(blossom, _blossom_set->classPrio(blossom) -
-                      (*_blossom_data)[blossom].offset);
-      }
-
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-      }
-    }
-
-    void oddToEven(int blossom, int tree) {
-      if (!_blossom_set->trivial(blossom)) {
-        _delta4->erase(blossom);
-        (*_blossom_data)[blossom].pot -=
-          2 * (2 * _delta_sum - (*_blossom_data)[blossom].offset);
-      }
-
-      for (typename BlossomSet::ItemIt n(*_blossom_set, blossom);
-           n != INVALID; ++n) {
-        int ni = (*_node_index)[n];
-
-        _blossom_set->increase(n, std::numeric_limits<Value>::max());
-
-        (*_node_data)[ni].heap.clear();
-        (*_node_data)[ni].heap_index.clear();
-        (*_node_data)[ni].pot +=
-          2 * _delta_sum - (*_blossom_data)[blossom].offset;
-
-        _delta1->push(n, (*_node_data)[ni].pot);
-
-        for (InArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.source(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-            if (_delta3->state(e) != _delta3->IN_HEAP && blossom != vb) {
-              _delta3->push(e, rw / 2);
-            }
-          } else {
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[vi].heap_index.find(tree);
-
-            if (it != (*_node_data)[vi].heap_index.end()) {
-              if ((*_node_data)[vi].heap[it->second] > rw) {
-                (*_node_data)[vi].heap.replace(it->second, e);
-                (*_node_data)[vi].heap.decrease(e, rw);
-                it->second = e;
+              (*_node_data)[ni].heap_index.find(vt);
+
+            if (it != (*_node_data)[ni].heap_index.end()) {
+              if ((*_node_data)[ni].heap[it->second] > rw) {
+                (*_node_data)[ni].heap.replace(it->second, r);
+                (*_node_data)[ni].heap.decrease(r, rw);
+                it->second = r;
               }
             } else {
-              (*_node_data)[vi].heap.push(e, rw);
-              (*_node_data)[vi].heap_index.insert(std::make_pair(tree, e));
-            }
-
-            if ((*_blossom_set)[v] > (*_node_data)[vi].heap.prio()) {
-              _blossom_set->decrease(v, (*_node_data)[vi].heap.prio());
-
-              if ((*_blossom_data)[vb].status == MATCHED) {
-                if (_delta2->state(vb) != _delta2->IN_HEAP) {
-                  _delta2->push(vb, _blossom_set->classPrio(vb) -
-                               (*_blossom_data)[vb].offset);
-                } else if ((*_delta2)[vb] > _blossom_set->classPrio(vb) -
-                           (*_blossom_data)[vb].offset) {
-                  _delta2->decrease(vb, _blossom_set->classPrio(vb) -
-                                   (*_blossom_data)[vb].offset);
-                }
+              (*_node_data)[ni].heap.push(r, rw);
+              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, r));
+            }
+
+            if ((*_blossom_set)[n] > (*_node_data)[ni].heap.prio()) {
+              _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
+
+              if (_delta2->state(blossom) != _delta2->IN_HEAP) {
+                _delta2->push(blossom, _blossom_set->classPrio(blossom) -
+                             (*_blossom_data)[blossom].offset);
+              } else if ((*_delta2)[blossom] > _blossom_set->classPrio(blossom)-
+                         (*_blossom_data)[blossom].offset){
+                _delta2->decrease(blossom, _blossom_set->classPrio(blossom) -
+                                 (*_blossom_data)[blossom].offset);
               }
             }
+
+          } else if ((*_blossom_data)[vb].status == UNMATCHED) {
+            if (_delta3->state(e) == _delta3->IN_HEAP) {
+              _delta3->erase(e);
+            }
           }
         }
       }
-      (*_blossom_data)[blossom].offset = 0;
     }
 
@@ -1208,7 +1314,9 @@
       destroyTree(tree);
 
+      (*_blossom_data)[blossom].status = UNMATCHED;
       (*_blossom_data)[blossom].base = node;
-      (*_blossom_data)[blossom].next = INVALID;
-    }
+      matchedToUnmatched(blossom);
+    }
+
 
     void augmentOnEdge(const Edge& edge) {
@@ -1217,29 +1325,24 @@
       int right = _blossom_set->find(_graph.v(edge));
 
-      int left_tree = _tree_set->find(left);
-      alternatePath(left, left_tree);
-      destroyTree(left_tree);
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
+      if ((*_blossom_data)[left].status == EVEN) {
+        int left_tree = _tree_set->find(left);
+        alternatePath(left, left_tree);
+        destroyTree(left_tree);
+      } else {
+        (*_blossom_data)[left].status = MATCHED;
+        unmatchedToMatched(left);
+      }
+
+      if ((*_blossom_data)[right].status == EVEN) {
+        int right_tree = _tree_set->find(right);
+        alternatePath(right, right_tree);
+        destroyTree(right_tree);
+      } else {
+        (*_blossom_data)[right].status = MATCHED;
+        unmatchedToMatched(right);
+      }
 
       (*_blossom_data)[left].next = _graph.direct(edge, true);
       (*_blossom_data)[right].next = _graph.direct(edge, false);
-    }
-
-    void augmentOnArc(const Arc& arc) {
-
-      int left = _blossom_set->find(_graph.source(arc));
-      int right = _blossom_set->find(_graph.target(arc));
-
-      (*_blossom_data)[left].status = MATCHED;
-
-      int right_tree = _tree_set->find(right);
-      alternatePath(right, right_tree);
-      destroyTree(right_tree);
-
-      (*_blossom_data)[left].next = arc;
-      (*_blossom_data)[right].next = _graph.oppositeArc(arc);
     }
 
@@ -1446,5 +1549,5 @@
           (*_blossom_data)[sb].pred = pred;
           (*_blossom_data)[sb].next =
-            _graph.oppositeArc((*_blossom_data)[tb].next);
+                           _graph.oppositeArc((*_blossom_data)[tb].next);
 
           pred = (*_blossom_data)[ub].next;
@@ -1546,5 +1649,5 @@
 
       for (int i = 0; i < int(blossoms.size()); ++i) {
-        if ((*_blossom_data)[blossoms[i]].next != INVALID) {
+        if ((*_blossom_data)[blossoms[i]].status == MATCHED) {
 
           Value offset = (*_blossom_data)[blossoms[i]].offset;
@@ -1584,14 +1687,8 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -1624,7 +1721,5 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
-
+      
       _delta1->clear();
       _delta2->clear();
@@ -1670,159 +1765,9 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      _fractional->run();
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        (*_delta1_index)[n] = _delta1->PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      _delta1->clear();
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        if (_fractional->matching(n) == INVALID) {
-          (*_blossom_data)[blossom].base = n;
-        }
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          _delta1->push(n, _fractional->nodeValue(n));
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            _delta1->push(v, _fractional->nodeValue(v));
-            v = _graph.target(_fractional->matching(v));
-          }
-
-          int surface =
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called
-    /// before using this function.
+    /// \pre \ref init() must be called before using this function.
     void start() {
       enum OpType {
@@ -1830,5 +1775,6 @@
       };
 
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d1 = !_delta1->empty() ?
           _delta1->prio() : std::numeric_limits<Value>::max();
@@ -1843,8 +1789,9 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d1 < _delta_sum) { _delta_sum = d1; ot = D1; }
+        _delta_sum = d1; OpType ot = D1;
         if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
+
 
         switch (ot) {
@@ -1853,5 +1800,5 @@
             Node n = _delta1->top();
             unmatchNode(n);
-            --_unmatched;
+            --unmatched;
           }
           break;
@@ -1860,11 +1807,6 @@
             int blossom = _delta2->top();
             Node n = _blossom_set->classTop(blossom);
-            Arc a = (*_node_data)[(*_node_index)[n]].heap.top();
-            if ((*_blossom_data)[blossom].next == INVALID) {
-              augmentOnArc(a);
-              --_unmatched;
-            } else {
-              extendOnArc(a);
-            }
+            Arc e = (*_node_data)[(*_node_index)[n]].heap.top();
+            extendOnArc(e);
           }
           break;
@@ -1879,6 +1821,18 @@
               _delta3->pop();
             } else {
-              int left_tree = _tree_set->find(left_blossom);
-              int right_tree = _tree_set->find(right_blossom);
+              int left_tree;
+              if ((*_blossom_data)[left_blossom].status == EVEN) {
+                left_tree = _tree_set->find(left_blossom);
+              } else {
+                left_tree = -1;
+                ++unmatched;
+              }
+              int right_tree;
+              if ((*_blossom_data)[right_blossom].status == EVEN) {
+                right_tree = _tree_set->find(right_blossom);
+              } else {
+                right_tree = -1;
+                ++unmatched;
+              }
 
               if (left_tree == right_tree) {
@@ -1886,5 +1840,5 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -1904,9 +1858,9 @@
     /// \note mwm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwm.fractionalInit();
+    ///   mwm.init();
     ///   mwm.start();
     /// \endcode
     void run() {
-      fractionalInit();
+      init();
       start();
     }
@@ -1915,5 +1869,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -1934,5 +1888,5 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
@@ -1954,5 +1908,5 @@
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -1965,5 +1919,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -1983,5 +1937,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -2003,6 +1957,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -2059,7 +2013,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedMatching class and execute it.
     class BlossomIt {
@@ -2070,6 +2024,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or
-      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be
+      /// \pre Either \ref MaxWeightedMatching::run() "algorithm.run()" or 
+      /// \ref MaxWeightedMatching::start() "algorithm.start()" must be 
       /// called before initializing this iterator.
       BlossomIt(const MaxWeightedMatching& algorithm, int variable)
@@ -2124,6 +2078,6 @@
   /// \f$O(nm\log n)\f$ time complexity.
   ///
-  /// The maximum weighted perfect matching problem is to find a subset of
-  /// the edges in an undirected graph with maximum overall weight for which
+  /// The maximum weighted perfect matching problem is to find a subset of 
+  /// the edges in an undirected graph with maximum overall weight for which 
   /// each node has exactly one incident edge.
   /// It can be formulated with the following linear program.
@@ -2148,14 +2102,14 @@
       \frac{\vert B \vert - 1}{2}z_B\f] */
   ///
-  /// The algorithm can be executed with the run() function.
+  /// The algorithm can be executed with the run() function. 
   /// After it the matching (the primal solution) and the dual solution
-  /// can be obtained using the query functions and the
-  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class,
-  /// which is able to iterate on the nodes of a blossom.
+  /// can be obtained using the query functions and the 
+  /// \ref MaxWeightedPerfectMatching::BlossomIt "BlossomIt" nested class, 
+  /// which is able to iterate on the nodes of a blossom. 
   /// If the value type is integer, then the dual solution is multiplied
   /// by \ref MaxWeightedMatching::dualScale "4".
   ///
   /// \tparam GR The undirected graph type the algorithm runs on.
-  /// \tparam WM The type edge weight map. The default type is
+  /// \tparam WM The type edge weight map. The default type is 
   /// \ref concepts::Graph::EdgeMap "GR::EdgeMap<int>".
 #ifdef DOXYGEN
@@ -2268,9 +2222,4 @@
 
     Value _delta_sum;
-    int _unmatched;
-
-    typedef MaxWeightedPerfectFractionalMatching<Graph, WeightMap>
-    FractionalMatching;
-    FractionalMatching *_fractional;
 
     void createStructures() {
@@ -2334,4 +2283,7 @@
 
     void destroyStructures() {
+      _node_num = countNodes(_graph);
+      _blossom_num = _node_num * 3 / 2;
+
       if (_matching) {
         delete _matching;
@@ -3006,14 +2958,8 @@
         _delta4_index(0), _delta4(0),
 
-        _delta_sum(), _unmatched(0),
-
-        _fractional(0)
-    {}
+        _delta_sum() {}
 
     ~MaxWeightedPerfectMatching() {
       destroyStructures();
-      if (_fractional) {
-        delete _fractional;
-      }
     }
 
@@ -3043,6 +2989,4 @@
         (*_delta4_index)[i] = _delta4->PRE_HEAP;
       }
-
-      _unmatched = _node_num;
 
       _delta2->clear();
@@ -3087,153 +3031,9 @@
     }
 
-    /// \brief Initialize the algorithm with fractional matching
-    ///
-    /// This function initializes the algorithm with a fractional
-    /// matching. This initialization is also called jumpstart heuristic.
-    void fractionalInit() {
-      createStructures();
-
-      _blossom_node_list.clear();
-      _blossom_potential.clear();
-
-      if (_fractional == 0) {
-        _fractional = new FractionalMatching(_graph, _weight, false);
-      }
-      if (!_fractional->run()) {
-        _unmatched = -1;
-        return;
-      }
-
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_node_heap_index)[e] = BinHeap<Value, IntArcMap>::PRE_HEAP;
-      }
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        (*_delta3_index)[e] = _delta3->PRE_HEAP;
-      }
-      for (int i = 0; i < _blossom_num; ++i) {
-        (*_delta2_index)[i] = _delta2->PRE_HEAP;
-        (*_delta4_index)[i] = _delta4->PRE_HEAP;
-      }
-
-      _unmatched = 0;
-
-      _delta2->clear();
-      _delta3->clear();
-      _delta4->clear();
-      _blossom_set->clear();
-      _tree_set->clear();
-
-      int index = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Value pot = _fractional->nodeValue(n);
-        (*_node_index)[n] = index;
-        (*_node_data)[index].pot = pot;
-        (*_node_data)[index].heap_index.clear();
-        (*_node_data)[index].heap.clear();
-        int blossom =
-          _blossom_set->insert(n, std::numeric_limits<Value>::max());
-
-        (*_blossom_data)[blossom].status = MATCHED;
-        (*_blossom_data)[blossom].pred = INVALID;
-        (*_blossom_data)[blossom].next = _fractional->matching(n);
-        (*_blossom_data)[blossom].pot = 0;
-        (*_blossom_data)[blossom].offset = 0;
-        ++index;
-      }
-
-      typename Graph::template NodeMap<bool> processed(_graph, false);
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        if (processed[n]) continue;
-        processed[n] = true;
-        if (_fractional->matching(n) == INVALID) continue;
-        int num = 1;
-        Node v = _graph.target(_fractional->matching(n));
-        while (n != v) {
-          processed[v] = true;
-          v = _graph.target(_fractional->matching(v));
-          ++num;
-        }
-
-        if (num % 2 == 1) {
-          std::vector<int> subblossoms(num);
-
-          subblossoms[--num] = _blossom_set->find(n);
-          v = _graph.target(_fractional->matching(n));
-          while (n != v) {
-            subblossoms[--num] = _blossom_set->find(v);
-            v = _graph.target(_fractional->matching(v));
-          }
-
-          int surface =
-            _blossom_set->join(subblossoms.begin(), subblossoms.end());
-          (*_blossom_data)[surface].status = EVEN;
-          (*_blossom_data)[surface].pred = INVALID;
-          (*_blossom_data)[surface].next = INVALID;
-          (*_blossom_data)[surface].pot = 0;
-          (*_blossom_data)[surface].offset = 0;
-
-          _tree_set->insert(surface);
-          ++_unmatched;
-        }
-      }
-
-      for (EdgeIt e(_graph); e != INVALID; ++e) {
-        int si = (*_node_index)[_graph.u(e)];
-        int sb = _blossom_set->find(_graph.u(e));
-        int ti = (*_node_index)[_graph.v(e)];
-        int tb = _blossom_set->find(_graph.v(e));
-        if ((*_blossom_data)[sb].status == EVEN &&
-            (*_blossom_data)[tb].status == EVEN && sb != tb) {
-          _delta3->push(e, ((*_node_data)[si].pot + (*_node_data)[ti].pot -
-                            dualScale * _weight[e]) / 2);
-        }
-      }
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        int nb = _blossom_set->find(n);
-        if ((*_blossom_data)[nb].status != MATCHED) continue;
-        int ni = (*_node_index)[n];
-
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node v = _graph.target(e);
-          int vb = _blossom_set->find(v);
-          int vi = (*_node_index)[v];
-
-          Value rw = (*_node_data)[ni].pot + (*_node_data)[vi].pot -
-            dualScale * _weight[e];
-
-          if ((*_blossom_data)[vb].status == EVEN) {
-
-            int vt = _tree_set->find(vb);
-
-            typename std::map<int, Arc>::iterator it =
-              (*_node_data)[ni].heap_index.find(vt);
-
-            if (it != (*_node_data)[ni].heap_index.end()) {
-              if ((*_node_data)[ni].heap[it->second] > rw) {
-                (*_node_data)[ni].heap.replace(it->second, e);
-                (*_node_data)[ni].heap.decrease(e, rw);
-                it->second = e;
-              }
-            } else {
-              (*_node_data)[ni].heap.push(e, rw);
-              (*_node_data)[ni].heap_index.insert(std::make_pair(vt, e));
-            }
-          }
-        }
-
-        if (!(*_node_data)[ni].heap.empty()) {
-          _blossom_set->decrease(n, (*_node_data)[ni].heap.prio());
-          _delta2->push(nb, _blossom_set->classPrio(nb));
-        }
-      }
-    }
-
     /// \brief Start the algorithm
     ///
     /// This function starts the algorithm.
     ///
-    /// \pre \ref init() or \ref fractionalInit() must be called before
-    /// using this function.
+    /// \pre \ref init() must be called before using this function.
     bool start() {
       enum OpType {
@@ -3241,7 +3041,6 @@
       };
 
-      if (_unmatched == -1) return false;
-
-      while (_unmatched > 0) {
+      int unmatched = _node_num;
+      while (unmatched > 0) {
         Value d2 = !_delta2->empty() ?
           _delta2->prio() : std::numeric_limits<Value>::max();
@@ -3253,6 +3052,6 @@
           _delta4->prio() : std::numeric_limits<Value>::max();
 
-        _delta_sum = d3; OpType ot = D3;
-        if (d2 < _delta_sum) { _delta_sum = d2; ot = D2; }
+        _delta_sum = d2; OpType ot = D2;
+        if (d3 < _delta_sum) { _delta_sum = d3; ot = D3; }
         if (d4 < _delta_sum) { _delta_sum = d4; ot = D4; }
 
@@ -3287,5 +3086,5 @@
               } else {
                 augmentOnEdge(e);
-                _unmatched -= 2;
+                unmatched -= 2;
               }
             }
@@ -3306,9 +3105,9 @@
     /// \note mwpm.run() is just a shortcut of the following code.
     /// \code
-    ///   mwpm.fractionalInit();
+    ///   mwpm.init();
     ///   mwpm.start();
     /// \endcode
     bool run() {
-      fractionalInit();
+      init();
       return start();
     }
@@ -3317,5 +3116,5 @@
 
     /// \name Primal Solution
-    /// Functions to get the primal solution, i.e. the maximum weighted
+    /// Functions to get the primal solution, i.e. the maximum weighted 
     /// perfect matching.\n
     /// Either \ref run() or \ref start() function should be called before
@@ -3336,10 +3135,10 @@
         }
       }
-      return sum / 2;
+      return sum /= 2;
     }
 
     /// \brief Return \c true if the given edge is in the matching.
     ///
-    /// This function returns \c true if the given edge is in the found
+    /// This function returns \c true if the given edge is in the found 
     /// matching.
     ///
@@ -3352,5 +3151,5 @@
     ///
     /// This function returns the matching arc (or edge) incident to the
-    /// given node in the found matching or \c INVALID if the node is
+    /// given node in the found matching or \c INVALID if the node is 
     /// not covered by the matching.
     ///
@@ -3370,5 +3169,5 @@
     /// \brief Return the mate of the given node.
     ///
-    /// This function returns the mate of the given node in the found
+    /// This function returns the mate of the given node in the found 
     /// matching or \c INVALID if the node is not covered by the matching.
     ///
@@ -3389,6 +3188,6 @@
     /// \brief Return the value of the dual solution.
     ///
-    /// This function returns the value of the dual solution.
-    /// It should be equal to the primal value scaled by \ref dualScale
+    /// This function returns the value of the dual solution. 
+    /// It should be equal to the primal value scaled by \ref dualScale 
     /// "dual scale".
     ///
@@ -3445,7 +3244,7 @@
     /// \brief Iterator for obtaining the nodes of a blossom.
     ///
-    /// This class provides an iterator for obtaining the nodes of the
+    /// This class provides an iterator for obtaining the nodes of the 
     /// given blossom. It lists a subset of the nodes.
-    /// Before using this iterator, you must allocate a
+    /// Before using this iterator, you must allocate a 
     /// MaxWeightedPerfectMatching class and execute it.
     class BlossomIt {
@@ -3456,6 +3255,6 @@
       /// Constructor to get the nodes of the given variable.
       ///
-      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()"
-      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()"
+      /// \pre Either \ref MaxWeightedPerfectMatching::run() "algorithm.run()" 
+      /// or \ref MaxWeightedPerfectMatching::start() "algorithm.start()" 
       /// must be called before initializing this iterator.
       BlossomIt(const MaxWeightedPerfectMatching& algorithm, int variable)
@@ -3503,3 +3302,3 @@
 } //END OF NAMESPACE LEMON
 
-#endif //LEMON_MATCHING_H
+#endif //LEMON_MAX_MATCHING_H
Index: lemon/math.h
===================================================================
--- lemon/math.h	(revision 877)
+++ lemon/math.h	(revision 487)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -57,5 +57,5 @@
 
   ///Check whether the parameter is NaN or not
-
+  
   ///This function checks whether the parameter is NaN or not.
   ///Is should be equivalent with std::isnan(), but it is not
Index: mon/max_cardinality_search.h
===================================================================
--- lemon/max_cardinality_search.h	(revision 977)
+++ 	(revision )
@@ -1,793 +1,0 @@
-/* -*- C++ -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library
- *
- * Copyright (C) 2003-2010
- * 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_MAX_CARDINALITY_SEARCH_H
-#define LEMON_MAX_CARDINALITY_SEARCH_H
-
-
-/// \ingroup search
-/// \file 
-/// \brief Maximum cardinality search in undirected digraphs.
-
-#include <lemon/bin_heap.h>
-#include <lemon/bucket_heap.h>
-
-#include <lemon/error.h>
-#include <lemon/maps.h>
-
-#include <functional>
-
-namespace lemon {
-
-  /// \brief Default traits class of MaxCardinalitySearch class.
-  ///
-  /// Default traits class of MaxCardinalitySearch class.
-  /// \param Digraph Digraph type.
-  /// \param CapacityMap Type of capacity map.
-  template <typename GR, typename CAP>
-  struct MaxCardinalitySearchDefaultTraits {
-    /// The digraph type the algorithm runs on. 
-    typedef GR Digraph;
-
-    template <typename CM>
-    struct CapMapSelector {
-
-      typedef CM CapacityMap;
-
-      static CapacityMap *createCapacityMap(const Digraph& g) {
-	return new CapacityMap(g);
-      }
-    };
-
-    template <typename CM>
-    struct CapMapSelector<ConstMap<CM, Const<int, 1> > > {
-
-      typedef ConstMap<CM, Const<int, 1> > CapacityMap;
-
-      static CapacityMap *createCapacityMap(const Digraph&) {
-	return new CapacityMap;
-      }
-    };
-
-    /// \brief The type of the map that stores the arc capacities.
-    ///
-    /// The type of the map that stores the arc capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef typename CapMapSelector<CAP>::CapacityMap CapacityMap;
-
-    /// \brief The type of the capacity of the arcs.
-    typedef typename CapacityMap::Value Value;
-
-    /// \brief Instantiates a CapacityMap.
-    ///
-    /// This function instantiates a \ref CapacityMap.
-    /// \param digraph is the digraph, to which we would like to define
-    /// the CapacityMap.
-    static CapacityMap *createCapacityMap(const Digraph& digraph) {
-      return CapMapSelector<CapacityMap>::createCapacityMap(digraph);
-    }
-
-    /// \brief The cross reference type used by heap.
-    ///
-    /// The cross reference type used by heap.
-    /// Usually it is \c Digraph::NodeMap<int>.
-    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
-
-    /// \brief Instantiates a HeapCrossRef.
-    ///
-    /// This function instantiates a \ref HeapCrossRef. 
-    /// \param digraph is the digraph, to which we would like to define the 
-    /// HeapCrossRef.
-    static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-      return new HeapCrossRef(digraph);
-    }
-    
-    template <typename CapacityMap>
-    struct HeapSelector {
-      template <typename Value, typename Ref>
-      struct Selector { 
-        typedef BinHeap<Value, Ref, std::greater<Value> > Heap;
-      };
-    };
-
-    template <typename CapacityKey>
-    struct HeapSelector<ConstMap<CapacityKey, Const<int, 1> > > {
-      template <typename Value, typename Ref>
-      struct Selector {
-        typedef BucketHeap<Ref, false > Heap;
-      };
-    };
-
-    /// \brief The heap type used by MaxCardinalitySearch algorithm.
-    ///
-    /// The heap type used by MaxCardinalitySearch algorithm. It should
-    /// maximalize the priorities. The default heap type is
-    /// the \ref BinHeap, but it is specialized when the
-    /// CapacityMap is ConstMap<Digraph::Node, Const<int, 1> >
-    /// to BucketHeap.
-    ///
-    /// \sa MaxCardinalitySearch
-    typedef typename HeapSelector<CapacityMap>
-    ::template Selector<Value, HeapCrossRef>
-    ::Heap Heap;
-
-    /// \brief Instantiates a Heap.
-    ///
-    /// This function instantiates a \ref Heap. 
-    /// \param crossref The cross reference of the heap.
-    static Heap *createHeap(HeapCrossRef& crossref) {
-      return new Heap(crossref);
-    }
-
-    /// \brief The type of the map that stores whether a node is processed.
-    ///
-    /// The type of the map that stores whether a node is processed.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    /// By default it is a NullMap.
-    typedef NullMap<typename Digraph::Node, bool> ProcessedMap;
-
-    /// \brief Instantiates a ProcessedMap.
-    ///
-    /// This function instantiates a \ref ProcessedMap. 
-    /// \param digraph is the digraph, to which
-    /// we would like to define the \ref ProcessedMap
-#ifdef DOXYGEN
-    static ProcessedMap *createProcessedMap(const Digraph &digraph)
-#else
-    static ProcessedMap *createProcessedMap(const Digraph &)
-#endif
-    {
-      return new ProcessedMap();
-    }
-
-    /// \brief The type of the map that stores the cardinalities of the nodes.
-    /// 
-    /// The type of the map that stores the cardinalities of the nodes.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept.
-    typedef typename Digraph::template NodeMap<Value> CardinalityMap;
-
-    /// \brief Instantiates a CardinalityMap.
-    ///
-    /// This function instantiates a \ref CardinalityMap. 
-    /// \param digraph is the digraph, to which we would like to define the \ref 
-    /// CardinalityMap
-    static CardinalityMap *createCardinalityMap(const Digraph &digraph) {
-      return new CardinalityMap(digraph);
-    }
-
-
-  };
-  
-  /// \ingroup search
-  ///
-  /// \brief Maximum Cardinality Search algorithm class.
-  ///
-  /// This class provides an efficient implementation of Maximum Cardinality 
-  /// Search algorithm. The maximum cardinality search first chooses any 
-  /// node of the digraph. Then every time it chooses one unprocessed node
-  /// with maximum cardinality, i.e the sum of capacities on out arcs to the nodes
-  /// which were previusly processed.
-  /// If there is a cut in the digraph the algorithm should choose
-  /// again any unprocessed node of the digraph.
-
-  /// The arc capacities are passed to the algorithm using a
-  /// \ref concepts::ReadMap "ReadMap", so it is easy to change it to any 
-  /// kind of capacity.
-  ///
-  /// The type of the capacity is determined by the \ref 
-  /// concepts::ReadMap::Value "Value" of the capacity map.
-  ///
-  /// It is also possible to change the underlying priority heap.
-  ///
-  ///
-  /// \param GR The digraph type the algorithm runs on. The value of
-  /// Digraph is not used directly by the search algorithm, it 
-  /// is only passed to \ref MaxCardinalitySearchDefaultTraits.
-  /// \param CAP This read-only ArcMap determines the capacities of 
-  /// the arcs. It is read once for each arc, so the map may involve in
-  /// relatively time consuming process to compute the arc capacity if
-  /// it is necessary. The default map type is \ref
-  /// ConstMap "ConstMap<concepts::Digraph::Arc, Const<int,1> >". The value
-  /// of CapacityMap is not used directly by search algorithm, it is only 
-  /// passed to \ref MaxCardinalitySearchDefaultTraits.  
-  /// \param TR Traits class to set various data types used by the 
-  /// algorithm.  The default traits class is 
-  /// \ref MaxCardinalitySearchDefaultTraits 
-  /// "MaxCardinalitySearchDefaultTraits<GR, CAP>".  
-  /// See \ref MaxCardinalitySearchDefaultTraits 
-  /// for the documentation of a MaxCardinalitySearch traits class.
-
-#ifdef DOXYGEN
-  template <typename GR, typename CAP, typename TR>
-#else
-  template <typename GR, typename CAP = 
-	    ConstMap<typename GR::Arc, Const<int,1> >,
-	    typename TR = 
-            MaxCardinalitySearchDefaultTraits<GR, CAP> >
-#endif
-  class MaxCardinalitySearch {
-  public:
-
-    typedef TR Traits;
-    ///The type of the underlying digraph.
-    typedef typename Traits::Digraph Digraph;
-    
-    ///The type of the capacity of the arcs.
-    typedef typename Traits::CapacityMap::Value Value;
-    ///The type of the map that stores the arc capacities.
-    typedef typename Traits::CapacityMap CapacityMap;
-    ///The type of the map indicating if a node is processed.
-    typedef typename Traits::ProcessedMap ProcessedMap;
-    ///The type of the map that stores the cardinalities of the nodes.
-    typedef typename Traits::CardinalityMap CardinalityMap;
-    ///The cross reference type used for the current heap.
-    typedef typename Traits::HeapCrossRef HeapCrossRef;
-    ///The heap type used by the algorithm. It maximizes the priorities.
-    typedef typename Traits::Heap Heap;
-  private:
-    // Pointer to the underlying digraph.
-    const Digraph *_graph;
-    // Pointer to the capacity map
-    const CapacityMap *_capacity;
-    // Indicates if \ref _capacity is locally allocated (\c true) or not.
-    bool local_capacity;
-    // Pointer to the map of cardinality.
-    CardinalityMap *_cardinality;
-    // Indicates if \ref _cardinality is locally allocated (\c true) or not.
-    bool local_cardinality;
-    // Pointer to the map of processed status of the nodes.
-    ProcessedMap *_processed;
-    // Indicates if \ref _processed is locally allocated (\c true) or not.
-    bool local_processed;
-    // Pointer to the heap cross references.
-    HeapCrossRef *_heap_cross_ref;
-    // Indicates if \ref _heap_cross_ref is locally allocated (\c true) or not.
-    bool local_heap_cross_ref;
-    // Pointer to the heap.
-    Heap *_heap;
-    // Indicates if \ref _heap is locally allocated (\c true) or not.
-    bool local_heap;
-
-  public :
-
-    typedef MaxCardinalitySearch Create;
- 
-    ///\name Named template parameters
-
-    ///@{
-
-    template <class T>
-    struct DefCapacityMapTraits : public Traits {
-      typedef T CapacityMap;
-      static CapacityMap *createCapacityMap(const Digraph &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
-    /// CapacityMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting CapacityMap type
-    /// for the algorithm.
-    template <class T>
-    struct SetCapacityMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefCapacityMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefCapacityMapTraits<T> > Create;
-    };
-
-    template <class T>
-    struct DefCardinalityMapTraits : public Traits {
-      typedef T CardinalityMap;
-      static CardinalityMap *createCardinalityMap(const Digraph &) 
-      {
-	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
-    /// CardinalityMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting CardinalityMap 
-    /// type for the algorithm.
-    template <class T>
-    struct SetCardinalityMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefCardinalityMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefCardinalityMapTraits<T> > Create;
-    };
-    
-    template <class T>
-    struct DefProcessedMapTraits : public Traits {
-      typedef T ProcessedMap;
-      static ProcessedMap *createProcessedMap(const Digraph &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting 
-    /// ProcessedMap type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting ProcessedMap type
-    /// for the algorithm.
-    template <class T>
-    struct SetProcessedMap 
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefProcessedMapTraits<T> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefProcessedMapTraits<T> > Create;
-    };
-    
-    template <class H, class CR>
-    struct DefHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(const Digraph &) {
-     	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-      static Heap *createHeap(HeapCrossRef &) {
-       	LEMON_ASSERT(false,"Uninitialized parameter.");
-	return 0;
-      }
-    };
-    /// \brief \ref named-templ-param "Named parameter" for setting heap 
-    /// and cross reference type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross 
-    /// reference type for the algorithm.
-    template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct SetHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefHeapTraits<H, CR> > { 
-      typedef MaxCardinalitySearch< Digraph, CapacityMap, 
-                                    DefHeapTraits<H, CR> > Create;
-    };
-
-    template <class H, class CR>
-    struct DefStandardHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(const Digraph &digraph) {
-	return new HeapCrossRef(digraph);
-      }
-      static Heap *createHeap(HeapCrossRef &crossref) {
-	return new Heap(crossref);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting heap and 
-    /// cross reference type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and cross 
-    /// reference type. It can allocate the heap and the cross reference 
-    /// object if the cross reference's constructor waits for the digraph as 
-    /// parameter and the heap's constructor waits for the cross reference.
-    template <class H, class CR = typename Digraph::template NodeMap<int> >
-    struct SetStandardHeap
-      : public MaxCardinalitySearch<Digraph, CapacityMap, 
-                                    DefStandardHeapTraits<H, CR> > { 
-      typedef MaxCardinalitySearch<Digraph, CapacityMap, 
-                                   DefStandardHeapTraits<H, CR> > 
-      Create;
-    };
-    
-    ///@}
-
-
-  protected:
-
-    MaxCardinalitySearch() {}
-
-  public:      
-    
-    /// \brief Constructor.
-    ///
-    ///\param digraph the digraph the algorithm will run on.
-    ///\param capacity the capacity map used by the algorithm.
-    MaxCardinalitySearch(const Digraph& digraph,
-			 const CapacityMap& capacity) :
-      _graph(&digraph),
-      _capacity(&capacity), local_capacity(false),
-      _cardinality(0), local_cardinality(false),
-      _processed(0), local_processed(false),
-      _heap_cross_ref(0), local_heap_cross_ref(false),
-      _heap(0), local_heap(false)
-    { }
-
-    /// \brief Constructor.
-    ///
-    ///\param digraph the digraph the algorithm will run on.
-    ///
-    ///A constant 1 capacity map will be allocated.
-    MaxCardinalitySearch(const Digraph& digraph) :
-      _graph(&digraph),
-      _capacity(0), local_capacity(false),
-      _cardinality(0), local_cardinality(false),
-      _processed(0), local_processed(false),
-      _heap_cross_ref(0), local_heap_cross_ref(false),
-      _heap(0), local_heap(false)
-    { }
-
-    /// \brief Destructor.
-    ~MaxCardinalitySearch() {
-      if(local_capacity) delete _capacity;
-      if(local_cardinality) delete _cardinality;
-      if(local_processed) delete _processed;
-      if(local_heap_cross_ref) delete _heap_cross_ref;
-      if(local_heap) delete _heap;
-    }
-
-    /// \brief Sets the capacity map.
-    ///
-    /// Sets the capacity map.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &capacityMap(const CapacityMap &m) {
-      if (local_capacity) {
-	delete _capacity;
-	local_capacity=false;
-      }
-      _capacity=&m;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the capacity map.
-    ///
-    /// Returns a const reference to the capacity map used by
-    /// the algorithm.
-    const CapacityMap &capacityMap() const {
-      return *_capacity;
-    }
-
-    /// \brief Sets the map storing the cardinalities calculated by the 
-    /// algorithm.
-    ///
-    /// Sets the map storing the cardinalities calculated by the algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &cardinalityMap(CardinalityMap &m) {
-      if(local_cardinality) {
-	delete _cardinality;
-	local_cardinality=false;
-      }
-      _cardinality = &m;
-      return *this;
-    }
-
-    /// \brief Sets the map storing the processed nodes.
-    ///
-    /// Sets the map storing the processed nodes.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &processedMap(ProcessedMap &m) 
-    {
-      if(local_processed) {
-	delete _processed;
-	local_processed=false;
-      }
-      _processed = &m;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the cardinality map.
-    ///
-    /// Returns a const reference to the cardinality map used by
-    /// the algorithm.
-    const ProcessedMap &processedMap() const {
-      return *_processed;
-    }
-
-    /// \brief Sets the heap and the cross reference used by algorithm.
-    ///
-    /// Sets the heap and the cross reference used by algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated map, of course.
-    /// \return <tt> (*this) </tt>
-    MaxCardinalitySearch &heap(Heap& hp, HeapCrossRef &cr) {
-      if(local_heap_cross_ref) {
-	delete _heap_cross_ref;
-	local_heap_cross_ref = false;
-      }
-      _heap_cross_ref = &cr;
-      if(local_heap) {
-	delete _heap;
-	local_heap = false;
-      }
-      _heap = &hp;
-      return *this;
-    }
-
-    /// \brief Returns a const reference to the heap.
-    ///
-    /// Returns a const reference to the heap used by
-    /// the algorithm.
-    const Heap &heap() const {
-      return *_heap;
-    }
-
-    /// \brief Returns a const reference to the cross reference.
-    ///
-    /// Returns a const reference to the cross reference
-    /// of the heap.
-    const HeapCrossRef &heapCrossRef() const {
-      return *_heap_cross_ref;
-    }
-
-  private:
-
-    typedef typename Digraph::Node Node;
-    typedef typename Digraph::NodeIt NodeIt;
-    typedef typename Digraph::Arc Arc;
-    typedef typename Digraph::InArcIt InArcIt;
-
-    void create_maps() {
-      if(!_capacity) {
-	local_capacity = true;
-	_capacity = Traits::createCapacityMap(*_graph);
-      }
-      if(!_cardinality) {
-	local_cardinality = true;
-	_cardinality = Traits::createCardinalityMap(*_graph);
-      }
-      if(!_processed) {
-	local_processed = true;
-	_processed = Traits::createProcessedMap(*_graph);
-      }
-      if (!_heap_cross_ref) {
-	local_heap_cross_ref = true;
-	_heap_cross_ref = Traits::createHeapCrossRef(*_graph);
-      }
-      if (!_heap) {
-	local_heap = true;
-	_heap = Traits::createHeap(*_heap_cross_ref);
-      }
-    }
-    
-    void finalizeNodeData(Node node, Value capacity) {
-      _processed->set(node, true);
-      _cardinality->set(node, capacity);
-    }
-
-  public:
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \ref run().
-    /// \n
-    /// If you need more control on the execution,
-    /// first you must call \ref init(), then you can add several source nodes
-    /// with \ref addSource().
-    /// Finally \ref start() will perform the computation.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures, and clears the heap.
-    void init() {
-      create_maps();
-      _heap->clear();
-      for (NodeIt it(*_graph) ; it != INVALID ; ++it) {
-	_processed->set(it, false);
-	_heap_cross_ref->set(it, Heap::PRE_HEAP);
-      }
-    }
-    
-    /// \brief Adds a new source node.
-    /// 
-    /// Adds a new source node to the priority heap.
-    ///
-    /// It checks if the node has not yet been added to the heap.
-    void addSource(Node source, Value capacity = 0) {
-      if(_heap->state(source) == Heap::PRE_HEAP) {
-	_heap->push(source, capacity);
-      } 
-    }
-    
-    /// \brief Processes the next node in the priority heap
-    ///
-    /// Processes the next node in the priority heap.
-    ///
-    /// \return The processed node.
-    ///
-    /// \warning The priority heap must not be empty!
-    Node processNextNode() {
-      Node node = _heap->top(); 
-      finalizeNodeData(node, _heap->prio());
-      _heap->pop();
-      
-      for (InArcIt it(*_graph, node); it != INVALID; ++it) {
-	Node source = _graph->source(it);
-	switch (_heap->state(source)) {
-	case Heap::PRE_HEAP:
-	  _heap->push(source, (*_capacity)[it]);
-	  break;
-	case Heap::IN_HEAP:
-	  _heap->decrease(source, (*_heap)[source] + (*_capacity)[it]);
-	  break;
-	case Heap::POST_HEAP:
-	  break;
-	}
-      }
-      return node;
-    }
-
-    /// \brief Next node to be processed.
-    ///
-    /// Next node to be processed.
-    ///
-    /// \return The next node to be processed or INVALID if the 
-    /// priority heap is empty.
-    Node nextNode() { 
-      return !_heap->empty() ? _heap->top() : INVALID;
-    }
- 
-    /// \brief Returns \c false if there are nodes
-    /// to be processed in the priority heap
-    ///
-    /// Returns \c false if there are nodes
-    /// to be processed in the priority heap
-    bool emptyQueue() { return _heap->empty(); }
-    /// \brief Returns the number of the nodes to be processed 
-    /// in the priority heap
-    ///
-    /// Returns the number of the nodes to be processed in the priority heap
-    int emptySize() { return _heap->size(); }
-    
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    ///\pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// This method runs the Maximum Cardinality Search algorithm from the 
-    /// source node(s).
-    void start() {
-      while ( !_heap->empty() ) processNextNode();
-    }
-    
-    /// \brief Executes the algorithm until \c dest is reached.
-    ///
-    /// Executes the algorithm until \c dest is reached.
-    ///
-    /// \pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from the source 
-    /// nodes.
-    void start(Node dest) {
-      while ( !_heap->empty() && _heap->top()!=dest ) processNextNode();
-      if ( !_heap->empty() ) finalizeNodeData(_heap->top(), _heap->prio());
-    }
-    
-    /// \brief Executes the algorithm until a condition is met.
-    ///
-    /// Executes the algorithm until a condition is met.
-    ///
-    /// \pre init() must be called and at least one node should be added
-    /// with addSource() before using this function.
-    ///
-    /// \param nm must be a bool (or convertible) node map. The algorithm
-    /// will stop when it reaches a node \c v with <tt>nm[v]==true</tt>.
-    template <typename NodeBoolMap>
-    void start(const NodeBoolMap &nm) {
-      while ( !_heap->empty() && !nm[_heap->top()] ) processNextNode();
-      if ( !_heap->empty() ) finalizeNodeData(_heap->top(),_heap->prio());
-    }
-    
-    /// \brief Runs the maximum cardinality search algorithm from node \c s.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from a root 
-    /// node \c s.
-    ///
-    ///\note d.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  d.init();
-    ///  d.addSource(s);
-    ///  d.start();
-    ///\endcode
-    void run(Node s) {
-      init();
-      addSource(s);
-      start();
-    }
-
-    /// \brief Runs the maximum cardinality search algorithm for the 
-    /// whole digraph.
-    ///
-    /// This method runs the %MaxCardinalitySearch algorithm from all 
-    /// unprocessed node of the digraph.
-    ///
-    ///\note d.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  d.init();
-    ///  for (NodeIt it(digraph); it != INVALID; ++it) {
-    ///    if (!d.reached(it)) {
-    ///      d.addSource(s);
-    ///      d.start();
-    ///    }
-    ///  }
-    ///\endcode
-    void run() {
-      init();
-      for (NodeIt it(*_graph); it != INVALID; ++it) {
-        if (!reached(it)) {
-          addSource(it);
-          start();
-        }
-      }
-    }
-    
-    ///@}
-
-    /// \name Query Functions
-    /// The results of the maximum cardinality search algorithm can be 
-    /// obtained using these functions.
-    /// \n
-    /// Before the use of these functions, either run() or start() must be 
-    /// called.
-    
-    ///@{
-
-    /// \brief The cardinality of a node.
-    ///
-    /// Returns the cardinality of a node.
-    /// \pre \ref run() must be called before using this function.
-    /// \warning If node \c v in unreachable from the root the return value
-    /// of this funcion is undefined.
-    Value cardinality(Node node) const { return (*_cardinality)[node]; }
-
-    /// \brief The current cardinality of a node.
-    ///
-    /// Returns the current cardinality of a node.
-    /// \pre the given node should be reached but not processed
-    Value currentCardinality(Node node) const { return (*_heap)[node]; }
-
-    /// \brief Returns a reference to the NodeMap of cardinalities.
-    ///
-    /// Returns a reference to the NodeMap of cardinalities. \pre \ref run() 
-    /// must be called before using this function.
-    const CardinalityMap &cardinalityMap() const { return *_cardinality;}
- 
-    /// \brief Checks if a node is reachable from the root.
-    ///
-    /// Returns \c true if \c v is reachable from the root.
-    /// \warning The source nodes are initated as unreached.
-    /// \pre \ref run() must be called before using this function.
-    bool reached(Node v) { return (*_heap_cross_ref)[v] != Heap::PRE_HEAP; }
-
-    /// \brief Checks if a node is processed.
-    ///
-    /// Returns \c true if \c v is processed, i.e. the shortest
-    /// path to \c v has already found.
-    /// \pre \ref run() must be called before using this function.
-    bool processed(Node v) { return (*_heap_cross_ref)[v] == Heap::POST_HEAP; }
-    
-    ///@}
-  };
-
-}
-
-#endif
Index: lemon/min_cost_arborescence.h
===================================================================
--- lemon/min_cost_arborescence.h	(revision 877)
+++ lemon/min_cost_arborescence.h	(revision 625)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -113,9 +113,8 @@
   /// it is necessary. The default map type is \ref
   /// concepts::Digraph::ArcMap "Digraph::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref MinCostArborescenceDefaultTraits
+  /// \param TR Traits class to set various data types used
+  /// by the algorithm. The default traits class is
+  /// \ref MinCostArborescenceDefaultTraits
   /// "MinCostArborescenceDefaultTraits<GR, CM>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
 #ifndef DOXYGEN
   template <typename GR,
@@ -124,11 +123,11 @@
               MinCostArborescenceDefaultTraits<GR, CM> >
 #else
-  template <typename GR, typename CM, typename TR>
+  template <typename GR, typename CM, typedef TR>
 #endif
   class MinCostArborescence {
   public:
 
-    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class"
-    /// of the algorithm.
+    /// \brief The \ref MinCostArborescenceDefaultTraits "traits class" 
+    /// of the algorithm. 
     typedef TR Traits;
     /// The type of the underlying digraph.
@@ -437,5 +436,5 @@
     /// \ref named-templ-param "Named parameter" for setting
     /// \c PredMap type.
-    /// It must meet the \ref concepts::WriteMap "WriteMap" concept,
+    /// It must meet the \ref concepts::WriteMap "WriteMap" concept, 
     /// and its value type must be the \c Arc type of the digraph.
     template <class T>
@@ -490,6 +489,6 @@
     /// The simplest way to execute the algorithm is to use
     /// one of the member functions called \c run(...). \n
-    /// If you need better control on the execution,
-    /// you have to call \ref init() first, then you can add several
+    /// If you need more control on the execution,
+    /// first you must call \ref init(), then you can add several
     /// source nodes with \ref addSource().
     /// Finally \ref start() will perform the arborescence
Index: mon/nagamochi_ibaraki.h
===================================================================
--- lemon/nagamochi_ibaraki.h	(revision 978)
+++ 	(revision )
@@ -1,702 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_NAGAMOCHI_IBARAKI_H
-#define LEMON_NAGAMOCHI_IBARAKI_H
-
-
-/// \ingroup min_cut
-/// \file
-/// \brief Implementation of the Nagamochi-Ibaraki algorithm.
-
-#include <lemon/core.h>
-#include <lemon/bin_heap.h>
-#include <lemon/bucket_heap.h>
-#include <lemon/maps.h>
-#include <lemon/radix_sort.h>
-#include <lemon/unionfind.h>
-
-#include <cassert>
-
-namespace lemon {
-
-  /// \brief Default traits class for NagamochiIbaraki class.
-  ///
-  /// Default traits class for NagamochiIbaraki class.
-  /// \param GR The undirected graph type.
-  /// \param CM Type of capacity map.
-  template <typename GR, typename CM>
-  struct NagamochiIbarakiDefaultTraits {
-    /// The type of the capacity map.
-    typedef typename CM::Value Value;
-
-    /// The undirected graph type the algorithm runs on.
-    typedef GR Graph;
-
-    /// \brief The type of the map that stores the edge capacities.
-    ///
-    /// The type of the map that stores the edge capacities.
-    /// It must meet the \ref concepts::ReadMap "ReadMap" concept.
-    typedef CM CapacityMap;
-
-    /// \brief Instantiates a CapacityMap.
-    ///
-    /// This function instantiates a \ref CapacityMap.
-#ifdef DOXYGEN
-    static CapacityMap *createCapacityMap(const Graph& graph)
-#else
-    static CapacityMap *createCapacityMap(const Graph&)
-#endif
-    {
-        LEMON_ASSERT(false, "CapacityMap is not initialized");
-        return 0; // ignore warnings
-    }
-
-    /// \brief The cross reference type used by heap.
-    ///
-    /// The cross reference type used by heap.
-    /// Usually \c Graph::NodeMap<int>.
-    typedef typename Graph::template NodeMap<int> HeapCrossRef;
-
-    /// \brief Instantiates a HeapCrossRef.
-    ///
-    /// This function instantiates a \ref HeapCrossRef.
-    /// \param g is the graph, to which we would like to define the
-    /// \ref HeapCrossRef.
-    static HeapCrossRef *createHeapCrossRef(const Graph& g) {
-      return new HeapCrossRef(g);
-    }
-
-    /// \brief The heap type used by NagamochiIbaraki algorithm.
-    ///
-    /// The heap type used by NagamochiIbaraki algorithm. It has to
-    /// maximize the priorities.
-    ///
-    /// \sa BinHeap
-    /// \sa NagamochiIbaraki
-    typedef BinHeap<Value, HeapCrossRef, std::greater<Value> > Heap;
-
-    /// \brief Instantiates a Heap.
-    ///
-    /// This function instantiates a \ref Heap.
-    /// \param r is the cross reference of the heap.
-    static Heap *createHeap(HeapCrossRef& r) {
-      return new Heap(r);
-    }
-  };
-
-  /// \ingroup min_cut
-  ///
-  /// \brief Calculates the minimum cut in an undirected graph.
-  ///
-  /// Calculates the minimum cut in an undirected graph with the
-  /// Nagamochi-Ibaraki algorithm. The algorithm separates the graph's
-  /// nodes into two partitions with the minimum sum of edge capacities
-  /// between the two partitions. The algorithm can be used to test
-  /// the network reliability, especially to test how many links have
-  /// to be destroyed in the network to split it to at least two
-  /// distinict subnetworks.
-  ///
-  /// The complexity of the algorithm is \f$ O(nm\log(n)) \f$ but with
-  /// \ref FibHeap "Fibonacci heap" it can be decreased to
-  /// \f$ O(nm+n^2\log(n)) \f$.  When the edges have unit capacities,
-  /// \c BucketHeap can be used which yields \f$ O(nm) \f$ time
-  /// complexity.
-  ///
-  /// \warning The value type of the capacity map should be able to
-  /// hold any cut value of the graph, otherwise the result can
-  /// overflow.
-  /// \note This capacity is supposed to be integer type.
-#ifdef DOXYGEN
-  template <typename GR, typename CM, typename TR>
-#else
-  template <typename GR,
-            typename CM = typename GR::template EdgeMap<int>,
-            typename TR = NagamochiIbarakiDefaultTraits<GR, CM> >
-#endif
-  class NagamochiIbaraki {
-  public:
-
-    typedef TR Traits;
-    /// The type of the underlying graph.
-    typedef typename Traits::Graph Graph;
-
-    /// The type of the capacity map.
-    typedef typename Traits::CapacityMap CapacityMap;
-    /// The value type of the capacity map.
-    typedef typename Traits::CapacityMap::Value Value;
-
-    /// The heap type used by the algorithm.
-    typedef typename Traits::Heap Heap;
-    /// The cross reference type used for the heap.
-    typedef typename Traits::HeapCrossRef HeapCrossRef;
-
-    ///\name Named template parameters
-
-    ///@{
-
-    struct SetUnitCapacityTraits : public Traits {
-      typedef ConstMap<typename Graph::Edge, Const<int, 1> > CapacityMap;
-      static CapacityMap *createCapacityMap(const Graph&) {
-        return new CapacityMap();
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// the capacity map to a constMap<Edge, int, 1>() instance
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// the capacity map to a constMap<Edge, int, 1>() instance
-    struct SetUnitCapacity
-      : public NagamochiIbaraki<Graph, CapacityMap,
-                                SetUnitCapacityTraits> {
-      typedef NagamochiIbaraki<Graph, CapacityMap,
-                               SetUnitCapacityTraits> Create;
-    };
-
-
-    template <class H, class CR>
-    struct SetHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(int num) {
-        LEMON_ASSERT(false, "HeapCrossRef is not initialized");
-        return 0; // ignore warnings
-      }
-      static Heap *createHeap(HeapCrossRef &) {
-        LEMON_ASSERT(false, "Heap is not initialized");
-        return 0; // ignore warnings
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// heap and cross reference type
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and
-    /// cross reference type. The heap has to maximize the priorities.
-    template <class H, class CR = RangeMap<int> >
-    struct SetHeap
-      : public NagamochiIbaraki<Graph, CapacityMap, SetHeapTraits<H, CR> > {
-      typedef NagamochiIbaraki< Graph, CapacityMap, SetHeapTraits<H, CR> >
-      Create;
-    };
-
-    template <class H, class CR>
-    struct SetStandardHeapTraits : public Traits {
-      typedef CR HeapCrossRef;
-      typedef H Heap;
-      static HeapCrossRef *createHeapCrossRef(int size) {
-        return new HeapCrossRef(size);
-      }
-      static Heap *createHeap(HeapCrossRef &crossref) {
-        return new Heap(crossref);
-      }
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// heap and cross reference type with automatic allocation
-    ///
-    /// \ref named-templ-param "Named parameter" for setting heap and
-    /// cross reference type with automatic allocation. They should
-    /// have standard constructor interfaces to be able to
-    /// automatically created by the algorithm (i.e. the graph should
-    /// be passed to the constructor of the cross reference and the
-    /// cross reference should be passed to the constructor of the
-    /// heap). However, external heap and cross reference objects
-    /// could also be passed to the algorithm using the \ref heap()
-    /// function before calling \ref run() or \ref init(). The heap
-    /// has to maximize the priorities.
-    /// \sa SetHeap
-    template <class H, class CR = RangeMap<int> >
-    struct SetStandardHeap
-      : public NagamochiIbaraki<Graph, CapacityMap,
-                                SetStandardHeapTraits<H, CR> > {
-      typedef NagamochiIbaraki<Graph, CapacityMap,
-                               SetStandardHeapTraits<H, CR> > Create;
-    };
-
-    ///@}
-
-
-  private:
-
-    const Graph &_graph;
-    const CapacityMap *_capacity;
-    bool _local_capacity; // unit capacity
-
-    struct ArcData {
-      typename Graph::Node target;
-      int prev, next;
-    };
-    struct EdgeData {
-      Value capacity;
-      Value cut;
-    };
-
-    struct NodeData {
-      int first_arc;
-      typename Graph::Node prev, next;
-      int curr_arc;
-      typename Graph::Node last_rep;
-      Value sum;
-    };
-
-    typename Graph::template NodeMap<NodeData> *_nodes;
-    std::vector<ArcData> _arcs;
-    std::vector<EdgeData> _edges;
-
-    typename Graph::Node _first_node;
-    int _node_num;
-
-    Value _min_cut;
-
-    HeapCrossRef *_heap_cross_ref;
-    bool _local_heap_cross_ref;
-    Heap *_heap;
-    bool _local_heap;
-
-    typedef typename Graph::template NodeMap<typename Graph::Node> NodeList;
-    NodeList *_next_rep;
-
-    typedef typename Graph::template NodeMap<bool> MinCutMap;
-    MinCutMap *_cut_map;
-
-    void createStructures() {
-      if (!_nodes) {
-        _nodes = new (typename Graph::template NodeMap<NodeData>)(_graph);
-      }
-      if (!_capacity) {
-        _local_capacity = true;
-        _capacity = Traits::createCapacityMap(_graph);
-      }
-      if (!_heap_cross_ref) {
-        _local_heap_cross_ref = true;
-        _heap_cross_ref = Traits::createHeapCrossRef(_graph);
-      }
-      if (!_heap) {
-        _local_heap = true;
-        _heap = Traits::createHeap(*_heap_cross_ref);
-      }
-      if (!_next_rep) {
-        _next_rep = new NodeList(_graph);
-      }
-      if (!_cut_map) {
-        _cut_map = new MinCutMap(_graph);
-      }
-    }
-
-  protected:
-    //This is here to avoid a gcc-3.3 compilation error.
-    //It should never be called.
-    NagamochiIbaraki() {} 
-    
-  public:
-
-    typedef NagamochiIbaraki Create;
-
-
-    /// \brief Constructor.
-    ///
-    /// \param graph The graph the algorithm runs on.
-    /// \param capacity The capacity map used by the algorithm.
-    NagamochiIbaraki(const Graph& graph, const CapacityMap& capacity)
-      : _graph(graph), _capacity(&capacity), _local_capacity(false),
-        _nodes(0), _arcs(), _edges(), _min_cut(),
-        _heap_cross_ref(0), _local_heap_cross_ref(false),
-        _heap(0), _local_heap(false),
-        _next_rep(0), _cut_map(0) {}
-
-    /// \brief Constructor.
-    ///
-    /// This constructor can be used only when the Traits class
-    /// defines how can the local capacity map be instantiated.
-    /// If the SetUnitCapacity used the algorithm automatically
-    /// constructs the capacity map.
-    ///
-    ///\param graph The graph the algorithm runs on.
-    NagamochiIbaraki(const Graph& graph)
-      : _graph(graph), _capacity(0), _local_capacity(false),
-        _nodes(0), _arcs(), _edges(), _min_cut(),
-        _heap_cross_ref(0), _local_heap_cross_ref(false),
-        _heap(0), _local_heap(false),
-        _next_rep(0), _cut_map(0) {}
-
-    /// \brief Destructor.
-    ///
-    /// Destructor.
-    ~NagamochiIbaraki() {
-      if (_local_capacity) delete _capacity;
-      if (_nodes) delete _nodes;
-      if (_local_heap) delete _heap;
-      if (_local_heap_cross_ref) delete _heap_cross_ref;
-      if (_next_rep) delete _next_rep;
-      if (_cut_map) delete _cut_map;
-    }
-
-    /// \brief Sets the heap and the cross reference used by algorithm.
-    ///
-    /// Sets the heap and the cross reference used by algorithm.
-    /// If you don't use this function before calling \ref run(),
-    /// it will allocate one. The destuctor deallocates this
-    /// automatically allocated heap and cross reference, of course.
-    /// \return <tt> (*this) </tt>
-    NagamochiIbaraki &heap(Heap& hp, HeapCrossRef &cr)
-    {
-      if (_local_heap_cross_ref) {
-        delete _heap_cross_ref;
-        _local_heap_cross_ref = false;
-      }
-      _heap_cross_ref = &cr;
-      if (_local_heap) {
-        delete _heap;
-        _local_heap = false;
-      }
-      _heap = &hp;
-      return *this;
-    }
-
-    /// \name Execution control
-    /// The simplest way to execute the algorithm is to use
-    /// one of the member functions called \c run().
-    /// \n
-    /// If you need more control on the execution,
-    /// first you must call \ref init() and then call the start()
-    /// or proper times the processNextPhase() member functions.
-
-    ///@{
-
-    /// \brief Initializes the internal data structures.
-    ///
-    /// Initializes the internal data structures.
-    void init() {
-      createStructures();
-
-      int edge_num = countEdges(_graph);
-      _edges.resize(edge_num);
-      _arcs.resize(2 * edge_num);
-
-      typename Graph::Node prev = INVALID;
-      _node_num = 0;
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        (*_cut_map)[n] = false;
-        (*_next_rep)[n] = INVALID;
-        (*_nodes)[n].last_rep = n;
-        (*_nodes)[n].first_arc = -1;
-        (*_nodes)[n].curr_arc = -1;
-        (*_nodes)[n].prev = prev;
-        if (prev != INVALID) {
-          (*_nodes)[prev].next = n;
-        }
-        (*_nodes)[n].next = INVALID;
-        (*_nodes)[n].sum = 0;
-        prev = n;
-        ++_node_num;
-      }
-
-      _first_node = typename Graph::NodeIt(_graph);
-
-      int index = 0;
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        for (typename Graph::OutArcIt a(_graph, n); a != INVALID; ++a) {
-          typename Graph::Node m = _graph.target(a);
-          
-          if (!(n < m)) continue;
-
-          (*_nodes)[n].sum += (*_capacity)[a];
-          (*_nodes)[m].sum += (*_capacity)[a];
-          
-          int c = (*_nodes)[m].curr_arc;
-          if (c != -1 && _arcs[c ^ 1].target == n) {
-            _edges[c >> 1].capacity += (*_capacity)[a];
-          } else {
-            _edges[index].capacity = (*_capacity)[a];
-            
-            _arcs[index << 1].prev = -1;
-            if ((*_nodes)[n].first_arc != -1) {
-              _arcs[(*_nodes)[n].first_arc].prev = (index << 1);
-            }
-            _arcs[index << 1].next = (*_nodes)[n].first_arc;
-            (*_nodes)[n].first_arc = (index << 1);
-            _arcs[index << 1].target = m;
-
-            (*_nodes)[m].curr_arc = (index << 1);
-            
-            _arcs[(index << 1) | 1].prev = -1;
-            if ((*_nodes)[m].first_arc != -1) {
-              _arcs[(*_nodes)[m].first_arc].prev = ((index << 1) | 1);
-            }
-            _arcs[(index << 1) | 1].next = (*_nodes)[m].first_arc;
-            (*_nodes)[m].first_arc = ((index << 1) | 1);
-            _arcs[(index << 1) | 1].target = n;
-            
-            ++index;
-          }
-        }
-      }
-
-      typename Graph::Node cut_node = INVALID;
-      _min_cut = std::numeric_limits<Value>::max();
-
-      for (typename Graph::Node n = _first_node; 
-           n != INVALID; n = (*_nodes)[n].next) {
-        if ((*_nodes)[n].sum < _min_cut) {
-          cut_node = n;
-          _min_cut = (*_nodes)[n].sum;
-        }
-      }
-      (*_cut_map)[cut_node] = true;
-      if (_min_cut == 0) {
-        _first_node = INVALID;
-      }
-    }
-
-  public:
-
-    /// \brief Processes the next phase
-    ///
-    /// Processes the next phase in the algorithm. It must be called
-    /// at most one less the number of the nodes in the graph.
-    ///
-    ///\return %True when the algorithm finished.
-    bool processNextPhase() {
-      if (_first_node == INVALID) return true;
-
-      _heap->clear();
-      for (typename Graph::Node n = _first_node; 
-           n != INVALID; n = (*_nodes)[n].next) {
-        (*_heap_cross_ref)[n] = Heap::PRE_HEAP;
-      }
-
-      std::vector<typename Graph::Node> order;
-      order.reserve(_node_num);
-      int sep = 0;
-
-      Value alpha = 0;
-      Value pmc = std::numeric_limits<Value>::max();
-
-      _heap->push(_first_node, static_cast<Value>(0));
-      while (!_heap->empty()) {
-        typename Graph::Node n = _heap->top();
-        Value v = _heap->prio();
-
-        _heap->pop();
-        for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) {
-          switch (_heap->state(_arcs[a].target)) {
-          case Heap::PRE_HEAP: 
-            {
-              Value nv = _edges[a >> 1].capacity;
-              _heap->push(_arcs[a].target, nv);
-              _edges[a >> 1].cut = nv;
-            } break;
-          case Heap::IN_HEAP:
-            {
-              Value nv = _edges[a >> 1].capacity + (*_heap)[_arcs[a].target];
-              _heap->decrease(_arcs[a].target, nv);
-              _edges[a >> 1].cut = nv;
-            } break;
-          case Heap::POST_HEAP:
-            break;
-          }
-        }
-
-        alpha += (*_nodes)[n].sum;
-        alpha -= 2 * v;
-
-        order.push_back(n);
-        if (!_heap->empty()) {
-          if (alpha < pmc) {
-            pmc = alpha;
-            sep = order.size();
-          }
-        }
-      }
-
-      if (static_cast<int>(order.size()) < _node_num) {
-        _first_node = INVALID;
-        for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-          (*_cut_map)[n] = false;
-        }
-        for (int i = 0; i < static_cast<int>(order.size()); ++i) {
-          typename Graph::Node n = order[i];
-          while (n != INVALID) {
-            (*_cut_map)[n] = true;
-            n = (*_next_rep)[n];
-          }
-        }
-        _min_cut = 0;
-        return true;
-      }
-
-      if (pmc < _min_cut) {
-        for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-          (*_cut_map)[n] = false;
-        }
-        for (int i = 0; i < sep; ++i) {
-          typename Graph::Node n = order[i];
-          while (n != INVALID) {
-            (*_cut_map)[n] = true;
-            n = (*_next_rep)[n];
-          }
-        }
-        _min_cut = pmc;
-      }
-
-      for (typename Graph::Node n = _first_node;
-           n != INVALID; n = (*_nodes)[n].next) {
-        bool merged = false;
-        for (int a = (*_nodes)[n].first_arc; a != -1; a = _arcs[a].next) {
-          if (!(_edges[a >> 1].cut < pmc)) {
-            if (!merged) {
-              for (int b = (*_nodes)[n].first_arc; b != -1; b = _arcs[b].next) {
-                (*_nodes)[_arcs[b].target].curr_arc = b;          
-              }
-              merged = true;
-            }
-            typename Graph::Node m = _arcs[a].target;
-            int nb = 0;
-            for (int b = (*_nodes)[m].first_arc; b != -1; b = nb) {
-              nb = _arcs[b].next;
-              if ((b ^ a) == 1) continue;
-              typename Graph::Node o = _arcs[b].target;
-              int c = (*_nodes)[o].curr_arc; 
-              if (c != -1 && _arcs[c ^ 1].target == n) {
-                _edges[c >> 1].capacity += _edges[b >> 1].capacity;
-                (*_nodes)[n].sum += _edges[b >> 1].capacity;
-                if (_edges[b >> 1].cut < _edges[c >> 1].cut) {
-                  _edges[b >> 1].cut = _edges[c >> 1].cut;
-                }
-                if (_arcs[b ^ 1].prev != -1) {
-                  _arcs[_arcs[b ^ 1].prev].next = _arcs[b ^ 1].next;
-                } else {
-                  (*_nodes)[o].first_arc = _arcs[b ^ 1].next;
-                }
-                if (_arcs[b ^ 1].next != -1) {
-                  _arcs[_arcs[b ^ 1].next].prev = _arcs[b ^ 1].prev;
-                }
-              } else {
-                if (_arcs[a].next != -1) {
-                  _arcs[_arcs[a].next].prev = b;
-                }
-                _arcs[b].next = _arcs[a].next;
-                _arcs[b].prev = a;
-                _arcs[a].next = b;
-                _arcs[b ^ 1].target = n;
-
-                (*_nodes)[n].sum += _edges[b >> 1].capacity;
-                (*_nodes)[o].curr_arc = b;
-              }
-            }
-
-            if (_arcs[a].prev != -1) {
-              _arcs[_arcs[a].prev].next = _arcs[a].next;
-            } else {
-              (*_nodes)[n].first_arc = _arcs[a].next;
-            }            
-            if (_arcs[a].next != -1) {
-              _arcs[_arcs[a].next].prev = _arcs[a].prev;
-            }
-
-            (*_nodes)[n].sum -= _edges[a >> 1].capacity;
-            (*_next_rep)[(*_nodes)[n].last_rep] = m;
-            (*_nodes)[n].last_rep = (*_nodes)[m].last_rep;
-            
-            if ((*_nodes)[m].prev != INVALID) {
-              (*_nodes)[(*_nodes)[m].prev].next = (*_nodes)[m].next;
-            } else{
-              _first_node = (*_nodes)[m].next;
-            }
-            if ((*_nodes)[m].next != INVALID) {
-              (*_nodes)[(*_nodes)[m].next].prev = (*_nodes)[m].prev;
-            }
-            --_node_num;
-          }
-        }
-      }
-
-      if (_node_num == 1) {
-        _first_node = INVALID;
-        return true;
-      }
-
-      return false;
-    }
-
-    /// \brief Executes the algorithm.
-    ///
-    /// Executes the algorithm.
-    ///
-    /// \pre init() must be called
-    void start() {
-      while (!processNextPhase()) {}
-    }
-
-
-    /// \brief Runs %NagamochiIbaraki algorithm.
-    ///
-    /// This method runs the %Min cut algorithm
-    ///
-    /// \note mc.run(s) is just a shortcut of the following code.
-    ///\code
-    ///  mc.init();
-    ///  mc.start();
-    ///\endcode
-    void run() {
-      init();
-      start();
-    }
-
-    ///@}
-
-    /// \name Query Functions
-    ///
-    /// The result of the %NagamochiIbaraki
-    /// algorithm can be obtained using these functions.\n
-    /// Before the use of these functions, either run() or start()
-    /// must be called.
-
-    ///@{
-
-    /// \brief Returns the min cut value.
-    ///
-    /// Returns the min cut value if the algorithm finished.
-    /// After the first processNextPhase() it is a value of a
-    /// valid cut in the graph.
-    Value minCutValue() const {
-      return _min_cut;
-    }
-
-    /// \brief Returns a min cut in a NodeMap.
-    ///
-    /// It sets the nodes of one of the two partitions to true and
-    /// the other partition to false.
-    /// \param cutMap A \ref concepts::WriteMap "writable" node map with
-    /// \c bool (or convertible) value type.
-    template <typename CutMap>
-    Value minCutMap(CutMap& cutMap) const {
-      for (typename Graph::NodeIt n(_graph); n != INVALID; ++n) {
-        cutMap.set(n, (*_cut_map)[n]);
-      }
-      return minCutValue();
-    }
-
-    ///@}
-
-  };
-}
-
-#endif
Index: lemon/network_simplex.h
===================================================================
--- lemon/network_simplex.h	(revision 984)
+++ lemon/network_simplex.h	(revision 888)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -41,15 +41,13 @@
   ///
   /// \ref NetworkSimplex implements the primal Network Simplex algorithm
-  /// for finding a \ref min_cost_flow "minimum cost flow"
-  /// \ref amo93networkflows, \ref dantzig63linearprog,
-  /// \ref kellyoneill91netsimplex.
-  /// This algorithm is a highly efficient specialized version of the
-  /// linear programming simplex method directly for the minimum cost
-  /// flow problem.
+  /// for finding a \ref min_cost_flow "minimum cost flow".
+  /// This algorithm is a specialized version of the linear programming
+  /// simplex method directly for the minimum cost flow problem.
+  /// It is one of the most efficient solution methods.
   ///
-  /// In general, \ref NetworkSimplex and \ref CostScaling are the fastest
-  /// implementations available in LEMON for this problem.
-  /// Furthermore, this class supports both directions of the supply/demand
-  /// inequality constraints. For more information, see \ref SupplyType.
+  /// In general this class is the fastest implementation available
+  /// in LEMON for the minimum cost flow problem.
+  /// Moreover it supports both directions of the supply/demand inequality
+  /// constraints. For more information see \ref SupplyType.
   ///
   /// Most of the parameters of the problem (except for the digraph)
@@ -59,16 +57,15 @@
   ///
   /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam V The number type used for flow amounts, capacity bounds
-  /// and supply values in the algorithm. By default, it is \c int.
-  /// \tparam C The number type used for costs and potentials in the
-  /// algorithm. By default, it is the same as \c V.
+  /// \tparam V The value type used for flow amounts, capacity bounds
+  /// and supply values in the algorithm. By default it is \c int.
+  /// \tparam C The value type used for costs and potentials in the
+  /// algorithm. By default it is the same as \c V.
   ///
-  /// \warning Both \c V and \c C must be signed number types.
-  /// \warning All input data (capacities, supply values, and costs) must
+  /// \warning Both value types must be signed and all input data must
   /// be integer.
   ///
   /// \note %NetworkSimplex provides five different pivot rule
   /// implementations, from which the most efficient one is used
-  /// by default. For more information, see \ref PivotRule.
+  /// by default. For more information see \ref PivotRule.
   template <typename GR, typename V = int, typename C = V>
   class NetworkSimplex
@@ -99,5 +96,5 @@
       UNBOUNDED
     };
-
+    
     /// \brief Constants for selecting the type of the supply constraints.
     ///
@@ -117,5 +114,5 @@
       LEQ
     };
-
+    
     /// \brief Constants for selecting the pivot rule.
     ///
@@ -123,27 +120,24 @@
     /// the \ref run() function.
     ///
-    /// \ref NetworkSimplex provides five different implementations for
-    /// the pivot strategy that significantly affects the running time
+    /// \ref NetworkSimplex provides five different pivot rule
+    /// implementations that significantly affect the running time
     /// of the algorithm.
-    /// According to experimental tests conducted on various problem
-    /// instances, \ref BLOCK_SEARCH "Block Search" and
-    /// \ref ALTERING_LIST "Altering Candidate List" rules turned out
-    /// to be the most efficient.
-    /// Since \ref BLOCK_SEARCH "Block Search" is a simpler strategy that
-    /// seemed to be slightly more robust, it is used by default.
-    /// However, another pivot rule can easily be selected using the
-    /// \ref run() function with the proper parameter.
+    /// By default \ref BLOCK_SEARCH "Block Search" is used, which
+    /// proved to be the most efficient and the most robust on various
+    /// test inputs according to our benchmark tests.
+    /// However another pivot rule can be selected using the \ref run()
+    /// function with the proper parameter.
     enum PivotRule {
 
-      /// The \e First \e Eligible pivot rule.
+      /// The First Eligible pivot rule.
       /// The next eligible arc is selected in a wraparound fashion
       /// in every iteration.
       FIRST_ELIGIBLE,
 
-      /// The \e Best \e Eligible pivot rule.
+      /// The Best Eligible pivot rule.
       /// The best eligible arc is selected in every iteration.
       BEST_ELIGIBLE,
 
-      /// The \e Block \e Search pivot rule.
+      /// The Block Search pivot rule.
       /// A specified number of arcs are examined in every iteration
       /// in a wraparound fashion and the best eligible arc is selected
@@ -151,5 +145,5 @@
       BLOCK_SEARCH,
 
-      /// The \e Candidate \e List pivot rule.
+      /// The Candidate List pivot rule.
       /// In a major iteration a candidate list is built from eligible arcs
       /// in a wraparound fashion and in the following minor iterations
@@ -157,33 +151,27 @@
       CANDIDATE_LIST,
 
-      /// The \e Altering \e Candidate \e List pivot rule.
+      /// The Altering Candidate List pivot rule.
       /// It is a modified version of the Candidate List method.
-      /// It keeps only a few of the best eligible arcs from the former
+      /// It keeps only the several best eligible arcs from the former
       /// candidate list and extends this list in every iteration.
       ALTERING_LIST
     };
-
+    
   private:
 
     TEMPLATE_DIGRAPH_TYPEDEFS(GR);
 
+    typedef std::vector<Arc> ArcVector;
+    typedef std::vector<Node> NodeVector;
     typedef std::vector<int> IntVector;
+    typedef std::vector<bool> BoolVector;
     typedef std::vector<Value> ValueVector;
     typedef std::vector<Cost> CostVector;
-    typedef std::vector<signed char> CharVector;
-    // Note: vector<signed char> is used instead of vector<ArcState> and
-    // vector<ArcDirection> for efficiency reasons
 
     // State constants for arcs
-    enum ArcState {
+    enum ArcStateEnum {
       STATE_UPPER = -1,
       STATE_TREE  =  0,
       STATE_LOWER =  1
-    };
-
-    // Direction constants for tree arcs
-    enum ArcDirection {
-      DIR_DOWN = -1,
-      DIR_UP   =  1
     };
 
@@ -207,5 +195,4 @@
     IntVector _source;
     IntVector _target;
-    bool _arc_mixing;
 
     // Node and arc data
@@ -225,17 +212,17 @@
     IntVector _succ_num;
     IntVector _last_succ;
-    CharVector _pred_dir;
-    CharVector _state;
     IntVector _dirty_revs;
+    BoolVector _forward;
+    IntVector _state;
     int _root;
 
     // Temporary data used in the current pivot iteration
     int in_arc, join, u_in, v_in, u_out, v_out;
+    int first, second, right, last;
+    int stem, par_stem, new_stem;
     Value delta;
 
-    const Value MAX;
-
   public:
-
+  
     /// \brief Constant for infinite upper bounds (capacities).
     ///
@@ -256,5 +243,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -277,5 +264,5 @@
       bool findEnteringArc() {
         Cost c;
-        for (int e = _next_arc; e != _search_arc_num; ++e) {
+        for (int e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -285,5 +272,5 @@
           }
         }
-        for (int e = 0; e != _next_arc; ++e) {
+        for (int e = 0; e < _next_arc; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -308,5 +295,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -325,5 +312,5 @@
       bool findEnteringArc() {
         Cost c, min = 0;
-        for (int e = 0; e != _search_arc_num; ++e) {
+        for (int e = 0; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
@@ -347,5 +334,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -366,5 +353,5 @@
       {
         // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
+        const double BLOCK_SIZE_FACTOR = 0.5;
         const int MIN_BLOCK_SIZE = 10;
 
@@ -378,30 +365,31 @@
         Cost c, min = 0;
         int cnt = _block_size;
-        int e;
-        for (e = _next_arc; e != _search_arc_num; ++e) {
+        int e, min_arc = _next_arc;
+        for (e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < min) {
             min = c;
-            _in_arc = e;
+            min_arc = e;
           }
           if (--cnt == 0) {
-            if (min < 0) goto search_end;
+            if (min < 0) break;
             cnt = _block_size;
           }
         }
-        for (e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < min) {
-            min = c;
-            _in_arc = e;
-          }
-          if (--cnt == 0) {
-            if (min < 0) goto search_end;
-            cnt = _block_size;
+        if (min == 0 || cnt > 0) {
+          for (e = 0; e < _next_arc; ++e) {
+            c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (c < min) {
+              min = c;
+              min_arc = e;
+            }
+            if (--cnt == 0) {
+              if (min < 0) break;
+              cnt = _block_size;
+            }
           }
         }
         if (min >= 0) return false;
-
-      search_end:
+        _in_arc = min_arc;
         _next_arc = e;
         return true;
@@ -420,5 +408,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -441,5 +429,5 @@
       {
         // The main parameters of the pivot rule
-        const double LIST_LENGTH_FACTOR = 0.25;
+        const double LIST_LENGTH_FACTOR = 1.0;
         const int MIN_LIST_LENGTH = 10;
         const double MINOR_LIMIT_FACTOR = 0.1;
@@ -458,5 +446,5 @@
       bool findEnteringArc() {
         Cost min, c;
-        int e;
+        int e, min_arc = _next_arc;
         if (_curr_length > 0 && _minor_count < _minor_limit) {
           // Minor iteration: select the best eligible arc from the
@@ -469,11 +457,14 @@
             if (c < min) {
               min = c;
-              _in_arc = e;
+              min_arc = e;
             }
-            else if (c >= 0) {
+            if (c >= 0) {
               _candidates[i--] = _candidates[--_curr_length];
             }
           }
-          if (min < 0) return true;
+          if (min < 0) {
+            _in_arc = min_arc;
+            return true;
+          }
         }
 
@@ -481,5 +472,5 @@
         min = 0;
         _curr_length = 0;
-        for (e = _next_arc; e != _search_arc_num; ++e) {
+        for (e = _next_arc; e < _search_arc_num; ++e) {
           c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
           if (c < 0) {
@@ -487,24 +478,25 @@
             if (c < min) {
               min = c;
-              _in_arc = e;
+              min_arc = e;
             }
-            if (_curr_length == _list_length) goto search_end;
-          }
-        }
-        for (e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _candidates[_curr_length++] = e;
-            if (c < min) {
-              min = c;
-              _in_arc = e;
+            if (_curr_length == _list_length) break;
+          }
+        }
+        if (_curr_length < _list_length) {
+          for (e = 0; e < _next_arc; ++e) {
+            c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (c < 0) {
+              _candidates[_curr_length++] = e;
+              if (c < min) {
+                min = c;
+                min_arc = e;
+              }
+              if (_curr_length == _list_length) break;
             }
-            if (_curr_length == _list_length) goto search_end;
           }
         }
         if (_curr_length == 0) return false;
-
-      search_end:
         _minor_count = 1;
+        _in_arc = min_arc;
         _next_arc = e;
         return true;
@@ -523,5 +515,5 @@
       const IntVector  &_target;
       const CostVector &_cost;
-      const CharVector &_state;
+      const IntVector  &_state;
       const CostVector &_pi;
       int &_in_arc;
@@ -542,5 +534,5 @@
         SortFunc(const CostVector &map) : _map(map) {}
         bool operator()(int left, int right) {
-          return _map[left] < _map[right];
+          return _map[left] > _map[right];
         }
       };
@@ -558,7 +550,7 @@
       {
         // The main parameters of the pivot rule
-        const double BLOCK_SIZE_FACTOR = 1.0;
+        const double BLOCK_SIZE_FACTOR = 1.5;
         const int MIN_BLOCK_SIZE = 10;
-        const double HEAD_LENGTH_FACTOR = 0.01;
+        const double HEAD_LENGTH_FACTOR = 0.1;
         const int MIN_HEAD_LENGTH = 3;
 
@@ -576,11 +568,9 @@
         // Check the current candidate list
         int e;
-        Cost c;
-        for (int i = 0; i != _curr_length; ++i) {
+        for (int i = 0; i < _curr_length; ++i) {
           e = _candidates[i];
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
-          } else {
+          _cand_cost[e] = _state[e] *
+            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (_cand_cost[e] >= 0) {
             _candidates[i--] = _candidates[--_curr_length];
           }
@@ -589,44 +579,47 @@
         // Extend the list
         int cnt = _block_size;
+        int last_arc = 0;
         int limit = _head_length;
 
-        for (e = _next_arc; e != _search_arc_num; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
+        for (int e = _next_arc; e < _search_arc_num; ++e) {
+          _cand_cost[e] = _state[e] *
+            (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+          if (_cand_cost[e] < 0) {
             _candidates[_curr_length++] = e;
+            last_arc = e;
           }
           if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
+            if (_curr_length > limit) break;
             limit = 0;
             cnt = _block_size;
           }
         }
-        for (e = 0; e != _next_arc; ++e) {
-          c = _state[e] * (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
-          if (c < 0) {
-            _cand_cost[e] = c;
-            _candidates[_curr_length++] = e;
-          }
-          if (--cnt == 0) {
-            if (_curr_length > limit) goto search_end;
-            limit = 0;
-            cnt = _block_size;
+        if (_curr_length <= limit) {
+          for (int e = 0; e < _next_arc; ++e) {
+            _cand_cost[e] = _state[e] *
+              (_cost[e] + _pi[_source[e]] - _pi[_target[e]]);
+            if (_cand_cost[e] < 0) {
+              _candidates[_curr_length++] = e;
+              last_arc = e;
+            }
+            if (--cnt == 0) {
+              if (_curr_length > limit) break;
+              limit = 0;
+              cnt = _block_size;
+            }
           }
         }
         if (_curr_length == 0) return false;
-
-      search_end:
-
-        // Perform partial sort operation on the candidate list
-        int new_length = std::min(_head_length + 1, _curr_length);
-        std::partial_sort(_candidates.begin(), _candidates.begin() + new_length,
-                          _candidates.begin() + _curr_length, _sort_func);
-
-        // Select the entering arc and remove it from the list
+        _next_arc = last_arc + 1;
+
+        // Make heap of the candidate list (approximating a partial sort)
+        make_heap( _candidates.begin(), _candidates.begin() + _curr_length,
+                   _sort_func );
+
+        // Pop the first element of the heap
         _in_arc = _candidates[0];
-        _next_arc = e;
-        _candidates[0] = _candidates[new_length - 1];
-        _curr_length = new_length - 1;
+        pop_heap( _candidates.begin(), _candidates.begin() + _curr_length,
+                  _sort_func );
+        _curr_length = std::min(_head_length, _curr_length - 1);
         return true;
       }
@@ -641,24 +634,67 @@
     ///
     /// \param graph The digraph the algorithm runs on.
-    /// \param arc_mixing Indicate if the arcs will be stored in a
-    /// mixed order in the internal data structure.
-    /// In general, it leads to similar performance as using the original
-    /// arc order, but it makes the algorithm more robust and in special
-    /// cases, even significantly faster. Therefore, it is enabled by default.
-    NetworkSimplex(const GR& graph, bool arc_mixing = true) :
+    NetworkSimplex(const GR& graph) :
       _graph(graph), _node_id(graph), _arc_id(graph),
-      _arc_mixing(arc_mixing),
-      MAX(std::numeric_limits<Value>::max()),
       INF(std::numeric_limits<Value>::has_infinity ?
-          std::numeric_limits<Value>::infinity() : MAX)
+          std::numeric_limits<Value>::infinity() :
+          std::numeric_limits<Value>::max())
     {
-      // Check the number types
+      // Check the value types
       LEMON_ASSERT(std::numeric_limits<Value>::is_signed,
         "The flow type of NetworkSimplex must be signed");
       LEMON_ASSERT(std::numeric_limits<Cost>::is_signed,
         "The cost type of NetworkSimplex must be signed");
-
-      // Reset data structures
-      reset();
+        
+      // Resize vectors
+      _node_num = countNodes(_graph);
+      _arc_num = countArcs(_graph);
+      int all_node_num = _node_num + 1;
+      int max_arc_num = _arc_num + 2 * _node_num;
+
+      _source.resize(max_arc_num);
+      _target.resize(max_arc_num);
+
+      _lower.resize(_arc_num);
+      _upper.resize(_arc_num);
+      _cap.resize(max_arc_num);
+      _cost.resize(max_arc_num);
+      _supply.resize(all_node_num);
+      _flow.resize(max_arc_num);
+      _pi.resize(all_node_num);
+
+      _parent.resize(all_node_num);
+      _pred.resize(all_node_num);
+      _forward.resize(all_node_num);
+      _thread.resize(all_node_num);
+      _rev_thread.resize(all_node_num);
+      _succ_num.resize(all_node_num);
+      _last_succ.resize(all_node_num);
+      _state.resize(max_arc_num);
+
+      // Copy the graph (store the arcs in a mixed order)
+      int i = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
+        _node_id[n] = i;
+      }
+      int k = std::max(int(std::sqrt(double(_arc_num))), 10);
+      i = 0;
+      for (ArcIt a(_graph); a != INVALID; ++a) {
+        _arc_id[a] = i;
+        _source[i] = _node_id[_graph.source(a)];
+        _target[i] = _node_id[_graph.target(a)];
+        if ((i += k) >= _arc_num) i = (i % k) + 1;
+      }
+      
+      // Initialize maps
+      for (int i = 0; i != _node_num; ++i) {
+        _supply[i] = 0;
+      }
+      for (int i = 0; i != _arc_num; ++i) {
+        _lower[i] = 0;
+        _upper[i] = INF;
+        _cost[i] = 1;
+      }
+      _have_lower = false;
+      _stype = GEQ;
     }
 
@@ -694,5 +730,5 @@
     /// If it is not used before calling \ref run(), the upper bounds
     /// will be set to \ref INF on all arcs (i.e. the flow value will be
-    /// unbounded from above).
+    /// unbounded from above on each arc).
     ///
     /// \param map An arc map storing the upper bounds.
@@ -733,4 +769,5 @@
     /// If neither this function nor \ref stSupply() is used before
     /// calling \ref run(), the supply of each node will be set to zero.
+    /// (It makes sense only if non-zero lower bounds are given.)
     ///
     /// \param map A node map storing the supply values.
@@ -739,6 +776,4 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \sa supplyType()
     template<typename SupplyMap>
     NetworkSimplex& supplyMap(const SupplyMap& map) {
@@ -755,7 +790,8 @@
     /// If neither this function nor \ref supplyMap() is used before
     /// calling \ref run(), the supply of each node will be set to zero.
+    /// (It makes sense only if non-zero lower bounds are given.)
     ///
     /// Using this function has the same effect as using \ref supplyMap()
-    /// with a map in which \c k is assigned to \c s, \c -k is
+    /// with such a map in which \c k is assigned to \c s, \c -k is
     /// assigned to \c t and all other nodes have zero supply value.
     ///
@@ -774,5 +810,5 @@
       return *this;
     }
-
+    
     /// \brief Set the type of the supply constraints.
     ///
@@ -781,5 +817,5 @@
     /// type will be used.
     ///
-    /// For more information, see \ref SupplyType.
+    /// For more information see \ref SupplyType.
     ///
     /// \return <tt>(*this)</tt>
@@ -800,5 +836,5 @@
     /// This function runs the algorithm.
     /// The paramters can be specified using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
+    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(), 
     /// \ref supplyType().
     /// For example,
@@ -809,13 +845,13 @@
     /// \endcode
     ///
-    /// This function can be called more than once. All the given parameters
-    /// are kept for the next call, unless \ref resetParams() or \ref reset()
-    /// is used, thus only the modified parameters have to be set again.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class (or the last \ref reset() call), then the \ref reset()
-    /// function must be called.
+    /// This function can be called more than once. All the parameters
+    /// that have been given are kept for the next call, unless
+    /// \ref reset() is called, thus only the modified parameters
+    /// have to be set again. See \ref reset() for examples.
+    /// However the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// \param pivot_rule The pivot rule that will be used during the
-    /// algorithm. For more information, see \ref PivotRule.
+    /// algorithm. For more information see \ref PivotRule.
     ///
     /// \return \c INFEASIBLE if no feasible flow exists,
@@ -828,5 +864,4 @@
     ///
     /// \see ProblemType, PivotRule
-    /// \see resetParams(), reset()
     ProblemType run(PivotRule pivot_rule = BLOCK_SEARCH) {
       if (!init()) return INFEASIBLE;
@@ -840,10 +875,9 @@
     /// \ref costMap(), \ref supplyMap(), \ref stSupply(), \ref supplyType().
     ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
+    /// It is useful for multiple run() calls. If this function is not
+    /// used, all the parameters given before are kept for the next
+    /// \ref run() call.
+    /// However the underlying digraph must not be modified after this
+    /// class have been constructed, since it copies and extends the graph.
     ///
     /// For example,
@@ -855,12 +889,12 @@
     ///     .supplyMap(sup).run();
     ///
-    ///   // Run again with modified cost map (resetParams() is not called,
+    ///   // Run again with modified cost map (reset() is not called,
     ///   // so only the cost map have to be set again)
     ///   cost[e] += 100;
     ///   ns.costMap(cost).run();
     ///
-    ///   // Run again from scratch using resetParams()
+    ///   // Run again from scratch using reset()
     ///   // (the lower bounds will be set to zero on all arcs)
-    ///   ns.resetParams();
+    ///   ns.reset();
     ///   ns.upperMap(capacity).costMap(cost)
     ///     .supplyMap(sup).run();
@@ -868,7 +902,5 @@
     ///
     /// \return <tt>(*this)</tt>
-    ///
-    /// \see reset(), run()
-    NetworkSimplex& resetParams() {
+    NetworkSimplex& reset() {
       for (int i = 0; i != _node_num; ++i) {
         _supply[i] = 0;
@@ -881,81 +913,4 @@
       _have_lower = false;
       _stype = GEQ;
-      return *this;
-    }
-
-    /// \brief Reset the internal data structures and all the parameters
-    /// that have been given before.
-    ///
-    /// This function resets the internal data structures and all the
-    /// paramaters that have been given before using functions \ref lowerMap(),
-    /// \ref upperMap(), \ref costMap(), \ref supplyMap(), \ref stSupply(),
-    /// \ref supplyType().
-    ///
-    /// It is useful for multiple \ref run() calls. Basically, all the given
-    /// parameters are kept for the next \ref run() call, unless
-    /// \ref resetParams() or \ref reset() is used.
-    /// If the underlying digraph was also modified after the construction
-    /// of the class or the last \ref reset() call, then the \ref reset()
-    /// function must be used, otherwise \ref resetParams() is sufficient.
-    ///
-    /// See \ref resetParams() for examples.
-    ///
-    /// \return <tt>(*this)</tt>
-    ///
-    /// \see resetParams(), run()
-    NetworkSimplex& reset() {
-      // Resize vectors
-      _node_num = countNodes(_graph);
-      _arc_num = countArcs(_graph);
-      int all_node_num = _node_num + 1;
-      int max_arc_num = _arc_num + 2 * _node_num;
-
-      _source.resize(max_arc_num);
-      _target.resize(max_arc_num);
-
-      _lower.resize(_arc_num);
-      _upper.resize(_arc_num);
-      _cap.resize(max_arc_num);
-      _cost.resize(max_arc_num);
-      _supply.resize(all_node_num);
-      _flow.resize(max_arc_num);
-      _pi.resize(all_node_num);
-
-      _parent.resize(all_node_num);
-      _pred.resize(all_node_num);
-      _pred_dir.resize(all_node_num);
-      _thread.resize(all_node_num);
-      _rev_thread.resize(all_node_num);
-      _succ_num.resize(all_node_num);
-      _last_succ.resize(all_node_num);
-      _state.resize(max_arc_num);
-
-      // Copy the graph
-      int i = 0;
-      for (NodeIt n(_graph); n != INVALID; ++n, ++i) {
-        _node_id[n] = i;
-      }
-      if (_arc_mixing) {
-        // Store the arcs in a mixed order
-        const int skip = std::max(_arc_num / _node_num, 3);
-        int i = 0, j = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-          if ((i += skip) >= _arc_num) i = ++j;
-        }
-      } else {
-        // Store the arcs in the original order
-        int i = 0;
-        for (ArcIt a(_graph); a != INVALID; ++a, ++i) {
-          _arc_id[a] = i;
-          _source[i] = _node_id[_graph.source(a)];
-          _target[i] = _node_id[_graph.target(a)];
-        }
-      }
-
-      // Reset parameters
-      resetParams();
       return *this;
     }
@@ -1070,7 +1025,7 @@
           Value c = _lower[i];
           if (c >= 0) {
-            _cap[i] = _upper[i] < MAX ? _upper[i] - c : INF;
+            _cap[i] = _upper[i] < INF ? _upper[i] - c : INF;
           } else {
-            _cap[i] = _upper[i] < MAX + c ? _upper[i] - c : INF;
+            _cap[i] = _upper[i] < INF + c ? _upper[i] - c : INF;
           }
           _supply[_source[i]] -= c;
@@ -1100,5 +1055,5 @@
         _state[i] = STATE_LOWER;
       }
-
+      
       // Set data for the artificial root node
       _root = _node_num;
@@ -1127,5 +1082,5 @@
           _state[e] = STATE_TREE;
           if (_supply[u] >= 0) {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = 0;
             _source[e] = u;
@@ -1134,5 +1089,5 @@
             _cost[e] = 0;
           } else {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = ART_COST;
             _source[e] = _root;
@@ -1154,5 +1109,5 @@
           _last_succ[u] = u;
           if (_supply[u] >= 0) {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = 0;
             _pred[u] = e;
@@ -1164,5 +1119,5 @@
             _state[e] = STATE_TREE;
           } else {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = ART_COST;
             _pred[u] = f;
@@ -1195,5 +1150,5 @@
           _last_succ[u] = u;
           if (_supply[u] <= 0) {
-            _pred_dir[u] = DIR_DOWN;
+            _forward[u] = false;
             _pi[u] = 0;
             _pred[u] = e;
@@ -1205,5 +1160,5 @@
             _state[e] = STATE_TREE;
           } else {
-            _pred_dir[u] = DIR_UP;
+            _forward[u] = true;
             _pi[u] = -ART_COST;
             _pred[u] = f;
@@ -1248,5 +1203,4 @@
       // Initialize first and second nodes according to the direction
       // of the cycle
-      int first, second;
       if (_state[in_arc] == STATE_LOWER) {
         first  = _source[in_arc];
@@ -1258,15 +1212,12 @@
       delta = _cap[in_arc];
       int result = 0;
-      Value c, d;
+      Value d;
       int e;
 
-      // Search the cycle form the first node to the join node
+      // Search the cycle along the path form the first node to the root
       for (int u = first; u != join; u = _parent[u]) {
         e = _pred[u];
-        d = _flow[e];
-        if (_pred_dir[u] == DIR_DOWN) {
-          c = _cap[e];
-          d = c >= MAX ? INF : c - d;
-        }
+        d = _forward[u] ?
+          _flow[e] : (_cap[e] == INF ? INF : _cap[e] - _flow[e]);
         if (d < delta) {
           delta = d;
@@ -1275,13 +1226,9 @@
         }
       }
-
-      // Search the cycle form the second node to the join node
+      // Search the cycle along the path form the second node to the root
       for (int u = second; u != join; u = _parent[u]) {
         e = _pred[u];
-        d = _flow[e];
-        if (_pred_dir[u] == DIR_UP) {
-          c = _cap[e];
-          d = c >= MAX ? INF : c - d;
-        }
+        d = _forward[u] ? 
+          (_cap[e] == INF ? INF : _cap[e] - _flow[e]) : _flow[e];
         if (d <= delta) {
           delta = d;
@@ -1308,8 +1255,8 @@
         _flow[in_arc] += val;
         for (int u = _source[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] -= _pred_dir[u] * val;
+          _flow[_pred[u]] += _forward[u] ? -val : val;
         }
         for (int u = _target[in_arc]; u != join; u = _parent[u]) {
-          _flow[_pred[u]] += _pred_dir[u] * val;
+          _flow[_pred[u]] += _forward[u] ? val : -val;
         }
       }
@@ -1326,4 +1273,5 @@
     // Update the tree structure
     void updateTreeStructure() {
+      int u, w;
       int old_rev_thread = _rev_thread[u_out];
       int old_succ_num = _succ_num[u_out];
@@ -1331,225 +1279,126 @@
       v_out = _parent[u_out];
 
-      // Check if u_in and u_out coincide
-      if (u_in == u_out) {
-        // Update _parent, _pred, _pred_dir
-        _parent[u_in] = v_in;
-        _pred[u_in] = in_arc;
-        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
-
-        // Update _thread and _rev_thread
-        if (_thread[v_in] != u_out) {
-          int after = _thread[old_last_succ];
-          _thread[old_rev_thread] = after;
-          _rev_thread[after] = old_rev_thread;
-          after = _thread[v_in];
-          _thread[v_in] = u_out;
-          _rev_thread[u_out] = v_in;
-          _thread[old_last_succ] = after;
-          _rev_thread[after] = old_last_succ;
-        }
+      u = _last_succ[u_in];  // the last successor of u_in
+      right = _thread[u];    // the node after it
+
+      // Handle the case when old_rev_thread equals to v_in
+      // (it also means that join and v_out coincide)
+      if (old_rev_thread == v_in) {
+        last = _thread[_last_succ[u_out]];
       } else {
-        // Handle the case when old_rev_thread equals to v_in
-        // (it also means that join and v_out coincide)
-        int thread_continue = old_rev_thread == v_in ?
-          _thread[old_last_succ] : _thread[v_in];
-
-        // Update _thread and _parent along the stem nodes (i.e. the nodes
-        // between u_in and u_out, whose parent have to be changed)
-        int stem = u_in;              // the current stem node
-        int par_stem = v_in;          // the new parent of stem
-        int next_stem;                // the next stem node
-        int last = _last_succ[u_in];  // the last successor of stem
-        int before, after = _thread[last];
-        _thread[v_in] = u_in;
-        _dirty_revs.clear();
-        _dirty_revs.push_back(v_in);
-        while (stem != u_out) {
-          // Insert the next stem node into the thread list
-          next_stem = _parent[stem];
-          _thread[last] = next_stem;
-          _dirty_revs.push_back(last);
-
-          // Remove the subtree of stem from the thread list
-          before = _rev_thread[stem];
-          _thread[before] = after;
-          _rev_thread[after] = before;
-
-          // Change the parent node and shift stem nodes
-          _parent[stem] = par_stem;
-          par_stem = stem;
-          stem = next_stem;
-
-          // Update last and after
-          last = _last_succ[stem] == _last_succ[par_stem] ?
-            _rev_thread[par_stem] : _last_succ[stem];
-          after = _thread[last];
-        }
-        _parent[u_out] = par_stem;
-        _thread[last] = thread_continue;
-        _rev_thread[thread_continue] = last;
-        _last_succ[u_out] = last;
-
-        // Remove the subtree of u_out from the thread list except for
-        // the case when old_rev_thread equals to v_in
-        if (old_rev_thread != v_in) {
-          _thread[old_rev_thread] = after;
-          _rev_thread[after] = old_rev_thread;
-        }
-
-        // Update _rev_thread using the new _thread values
-        for (int i = 0; i != int(_dirty_revs.size()); ++i) {
-          int u = _dirty_revs[i];
-          _rev_thread[_thread[u]] = u;
-        }
-
-        // Update _pred, _pred_dir, _last_succ and _succ_num for the
-        // stem nodes from u_out to u_in
-        int tmp_sc = 0, tmp_ls = _last_succ[u_out];
-        for (int u = u_out, p = _parent[u]; u != u_in; u = p, p = _parent[u]) {
-          _pred[u] = _pred[p];
-          _pred_dir[u] = -_pred_dir[p];
-          tmp_sc += _succ_num[u] - _succ_num[p];
-          _succ_num[u] = tmp_sc;
-          _last_succ[p] = tmp_ls;
-        }
-        _pred[u_in] = in_arc;
-        _pred_dir[u_in] = u_in == _source[in_arc] ? DIR_UP : DIR_DOWN;
-        _succ_num[u_in] = old_succ_num;
+        last = _thread[v_in];
+      }
+
+      // Update _thread and _parent along the stem nodes (i.e. the nodes
+      // between u_in and u_out, whose parent have to be changed)
+      _thread[v_in] = stem = u_in;
+      _dirty_revs.clear();
+      _dirty_revs.push_back(v_in);
+      par_stem = v_in;
+      while (stem != u_out) {
+        // Insert the next stem node into the thread list
+        new_stem = _parent[stem];
+        _thread[u] = new_stem;
+        _dirty_revs.push_back(u);
+
+        // Remove the subtree of stem from the thread list
+        w = _rev_thread[stem];
+        _thread[w] = right;
+        _rev_thread[right] = w;
+
+        // Change the parent node and shift stem nodes
+        _parent[stem] = par_stem;
+        par_stem = stem;
+        stem = new_stem;
+
+        // Update u and right
+        u = _last_succ[stem] == _last_succ[par_stem] ?
+          _rev_thread[par_stem] : _last_succ[stem];
+        right = _thread[u];
+      }
+      _parent[u_out] = par_stem;
+      _thread[u] = last;
+      _rev_thread[last] = u;
+      _last_succ[u_out] = u;
+
+      // Remove the subtree of u_out from the thread list except for
+      // the case when old_rev_thread equals to v_in
+      // (it also means that join and v_out coincide)
+      if (old_rev_thread != v_in) {
+        _thread[old_rev_thread] = right;
+        _rev_thread[right] = old_rev_thread;
+      }
+
+      // Update _rev_thread using the new _thread values
+      for (int i = 0; i < int(_dirty_revs.size()); ++i) {
+        u = _dirty_revs[i];
+        _rev_thread[_thread[u]] = u;
+      }
+
+      // Update _pred, _forward, _last_succ and _succ_num for the
+      // stem nodes from u_out to u_in
+      int tmp_sc = 0, tmp_ls = _last_succ[u_out];
+      u = u_out;
+      while (u != u_in) {
+        w = _parent[u];
+        _pred[u] = _pred[w];
+        _forward[u] = !_forward[w];
+        tmp_sc += _succ_num[u] - _succ_num[w];
+        _succ_num[u] = tmp_sc;
+        _last_succ[w] = tmp_ls;
+        u = w;
+      }
+      _pred[u_in] = in_arc;
+      _forward[u_in] = (u_in == _source[in_arc]);
+      _succ_num[u_in] = old_succ_num;
+
+      // Set limits for updating _last_succ form v_in and v_out
+      // towards the root
+      int up_limit_in = -1;
+      int up_limit_out = -1;
+      if (_last_succ[join] == v_in) {
+        up_limit_out = join;
+      } else {
+        up_limit_in = join;
       }
 
       // Update _last_succ from v_in towards the root
-      int up_limit_out = _last_succ[join] == v_in ? join : -1;
-      int last_succ_out = _last_succ[u_out];
-      for (int u = v_in; u != -1 && _last_succ[u] == v_in; u = _parent[u]) {
-        _last_succ[u] = last_succ_out;
-      }
-
+      for (u = v_in; u != up_limit_in && _last_succ[u] == v_in;
+           u = _parent[u]) {
+        _last_succ[u] = _last_succ[u_out];
+      }
       // Update _last_succ from v_out towards the root
       if (join != old_rev_thread && v_in != old_rev_thread) {
-        for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
+        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
              u = _parent[u]) {
           _last_succ[u] = old_rev_thread;
         }
-      }
-      else if (last_succ_out != old_last_succ) {
-        for (int u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
+      } else {
+        for (u = v_out; u != up_limit_out && _last_succ[u] == old_last_succ;
              u = _parent[u]) {
-          _last_succ[u] = last_succ_out;
+          _last_succ[u] = _last_succ[u_out];
         }
       }
 
       // Update _succ_num from v_in to join
-      for (int u = v_in; u != join; u = _parent[u]) {
+      for (u = v_in; u != join; u = _parent[u]) {
         _succ_num[u] += old_succ_num;
       }
       // Update _succ_num from v_out to join
-      for (int u = v_out; u != join; u = _parent[u]) {
+      for (u = v_out; u != join; u = _parent[u]) {
         _succ_num[u] -= old_succ_num;
       }
     }
 
-    // Update potentials in the subtree that has been moved
+    // Update potentials
     void updatePotential() {
-      Cost sigma = _pi[v_in] - _pi[u_in] -
-                   _pred_dir[u_in] * _cost[in_arc];
+      Cost sigma = _forward[u_in] ?
+        _pi[v_in] - _pi[u_in] - _cost[_pred[u_in]] :
+        _pi[v_in] - _pi[u_in] + _cost[_pred[u_in]];
+      // Update potentials in the subtree, which has been moved
       int end = _thread[_last_succ[u_in]];
       for (int u = u_in; u != end; u = _thread[u]) {
         _pi[u] += sigma;
       }
-    }
-
-    // Heuristic initial pivots
-    bool initialPivots() {
-      Value curr, total = 0;
-      std::vector<Node> supply_nodes, demand_nodes;
-      for (NodeIt u(_graph); u != INVALID; ++u) {
-        curr = _supply[_node_id[u]];
-        if (curr > 0) {
-          total += curr;
-          supply_nodes.push_back(u);
-        }
-        else if (curr < 0) {
-          demand_nodes.push_back(u);
-        }
-      }
-      if (_sum_supply > 0) total -= _sum_supply;
-      if (total <= 0) return true;
-
-      IntVector arc_vector;
-      if (_sum_supply >= 0) {
-        if (supply_nodes.size() == 1 && demand_nodes.size() == 1) {
-          // Perform a reverse graph search from the sink to the source
-          typename GR::template NodeMap<bool> reached(_graph, false);
-          Node s = supply_nodes[0], t = demand_nodes[0];
-          std::vector<Node> stack;
-          reached[t] = true;
-          stack.push_back(t);
-          while (!stack.empty()) {
-            Node u, v = stack.back();
-            stack.pop_back();
-            if (v == s) break;
-            for (InArcIt a(_graph, v); a != INVALID; ++a) {
-              if (reached[u = _graph.source(a)]) continue;
-              int j = _arc_id[a];
-              if (_cap[j] >= total) {
-                arc_vector.push_back(j);
-                reached[u] = true;
-                stack.push_back(u);
-              }
-            }
-          }
-        } else {
-          // Find the min. cost incomming arc for each demand node
-          for (int i = 0; i != int(demand_nodes.size()); ++i) {
-            Node v = demand_nodes[i];
-            Cost c, min_cost = std::numeric_limits<Cost>::max();
-            Arc min_arc = INVALID;
-            for (InArcIt a(_graph, v); a != INVALID; ++a) {
-              c = _cost[_arc_id[a]];
-              if (c < min_cost) {
-                min_cost = c;
-                min_arc = a;
-              }
-            }
-            if (min_arc != INVALID) {
-              arc_vector.push_back(_arc_id[min_arc]);
-            }
-          }
-        }
-      } else {
-        // Find the min. cost outgoing arc for each supply node
-        for (int i = 0; i != int(supply_nodes.size()); ++i) {
-          Node u = supply_nodes[i];
-          Cost c, min_cost = std::numeric_limits<Cost>::max();
-          Arc min_arc = INVALID;
-          for (OutArcIt a(_graph, u); a != INVALID; ++a) {
-            c = _cost[_arc_id[a]];
-            if (c < min_cost) {
-              min_cost = c;
-              min_arc = a;
-            }
-          }
-          if (min_arc != INVALID) {
-            arc_vector.push_back(_arc_id[min_arc]);
-          }
-        }
-      }
-
-      // Perform heuristic initial pivots
-      for (int i = 0; i != int(arc_vector.size()); ++i) {
-        in_arc = arc_vector[i];
-        if (_state[in_arc] * (_cost[in_arc] + _pi[_source[in_arc]] -
-            _pi[_target[in_arc]]) >= 0) continue;
-        findJoinNode();
-        bool change = findLeavingArc();
-        if (delta >= MAX) return false;
-        changeFlow(change);
-        if (change) {
-          updateTreeStructure();
-          updatePotential();
-        }
-      }
-      return true;
     }
 
@@ -1576,12 +1425,9 @@
       PivotRuleImpl pivot(*this);
 
-      // Perform heuristic initial pivots
-      if (!initialPivots()) return UNBOUNDED;
-
       // Execute the Network Simplex algorithm
       while (pivot.findEnteringArc()) {
         findJoinNode();
         bool change = findLeavingArc();
-        if (delta >= MAX) return UNBOUNDED;
+        if (delta >= INF) return UNBOUNDED;
         changeFlow(change);
         if (change) {
@@ -1590,5 +1436,5 @@
         }
       }
-
+      
       // Check feasibility
       for (int e = _search_arc_num; e != _all_arc_num; ++e) {
@@ -1607,5 +1453,5 @@
         }
       }
-
+      
       // Shift potentials to meet the requirements of the GEQ/LEQ type
       // optimality conditions
Index: mon/pairing_heap.h
===================================================================
--- lemon/pairing_heap.h	(revision 705)
+++ 	(revision )
@@ -1,474 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_PAIRING_HEAP_H
-#define LEMON_PAIRING_HEAP_H
-
-///\file
-///\ingroup heaps
-///\brief Pairing heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-#include <lemon/math.h>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Pairing Heap.
-  ///
-  /// This class implements the \e pairing \e heap data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The methods \ref increase() and \ref erase() are not efficient
-  /// in a pairing heap. In case of many calls of these operations,
-  /// it is better to use other heap structure, e.g. \ref BinHeap
-  /// "binary heap".
-  ///
-  /// \tparam PR Type of the priorities of the items.
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
-  /// \tparam CMP A functor class for comparing the priorities.
-  /// The default is \c std::less<PR>.
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class PairingHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    class store;
-
-    std::vector<store> _data;
-    int _min;
-    ItemIntMap &_iim;
-    Compare _comp;
-    int _num_items;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit PairingHeap(ItemIntMap &map)
-      : _min(0), _iim(map), _num_items(0) {}
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param comp The function object used for comparing the priorities.
-    PairingHeap(ItemIntMap &map, const Compare &comp)
-      : _min(0), _iim(map), _comp(comp), _num_items(0) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _num_items; }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _num_items==0; }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() {
-      _data.clear();
-      _min = 0;
-      _num_items = 0;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param item The item.
-    /// \param value The priority.
-    void set (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if ( i>=0 && _data[i].in ) {
-        if ( _comp(value, _data[i].prio) ) decrease(item, value);
-        if ( _comp(_data[i].prio, value) ) increase(item, value);
-      } else push(item, value);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param item The item to insert.
-    /// \param value The priority of the item.
-    /// \pre \e item must not be stored in the heap.
-    void push (const Item& item, const Prio& value) {
-      int i=_iim[item];
-      if( i<0 ) {
-        int s=_data.size();
-        _iim.set(item, s);
-        store st;
-        st.name=item;
-        _data.push_back(st);
-        i=s;
-      } else {
-        _data[i].parent=_data[i].child=-1;
-        _data[i].left_child=false;
-        _data[i].degree=0;
-        _data[i].in=true;
-      }
-
-      _data[i].prio=value;
-
-      if ( _num_items!=0 ) {
-        if ( _comp( value, _data[_min].prio) ) {
-          fuse(i,_min);
-          _min=i;
-        }
-        else fuse(_min,i);
-      }
-      else _min=i;
-
-      ++_num_items;
-    }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[_min].name; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    const Prio& prio() const { return _data[_min].prio; }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param item The item.
-    /// \pre \e item must be in the heap.
-    const Prio& operator[](const Item& item) const {
-      return _data[_iim[item]].prio;
-    }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      std::vector<int> trees;
-      int i=0, child_right = 0;
-      _data[_min].in=false;
-
-      if( -1!=_data[_min].child ) {
-        i=_data[_min].child;
-        trees.push_back(i);
-        _data[i].parent = -1;
-        _data[_min].child = -1;
-
-        int ch=-1;
-        while( _data[i].child!=-1 ) {
-          ch=_data[i].child;
-          if( _data[ch].left_child && i==_data[ch].parent ) {
-            break;
-          } else {
-            if( _data[ch].left_child ) {
-              child_right=_data[ch].parent;
-              _data[ch].parent = i;
-              --_data[i].degree;
-            }
-            else {
-              child_right=ch;
-              _data[i].child=-1;
-              _data[i].degree=0;
-            }
-            _data[child_right].parent = -1;
-            trees.push_back(child_right);
-            i = child_right;
-          }
-        }
-
-        int num_child = trees.size();
-        int other;
-        for( i=0; i<num_child-1; i+=2 ) {
-          if ( !_comp(_data[trees[i]].prio, _data[trees[i+1]].prio) ) {
-            other=trees[i];
-            trees[i]=trees[i+1];
-            trees[i+1]=other;
-          }
-          fuse( trees[i], trees[i+1] );
-        }
-
-        i = (0==(num_child % 2)) ? num_child-2 : num_child-1;
-        while(i>=2) {
-          if ( _comp(_data[trees[i]].prio, _data[trees[i-2]].prio) ) {
-            other=trees[i];
-            trees[i]=trees[i-2];
-            trees[i-2]=other;
-          }
-          fuse( trees[i-2], trees[i] );
-          i-=2;
-        }
-        _min = trees[0];
-      }
-      else {
-        _min = _data[_min].child;
-      }
-
-      if (_min >= 0) _data[_min].left_child = false;
-      --_num_items;
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param item The item to delete.
-    /// \pre \e item must be in the heap.
-    void erase (const Item& item) {
-      int i=_iim[item];
-      if ( i>=0 && _data[i].in ) {
-        decrease( item, _data[_min].prio-1 );
-        pop();
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at least \e value.
-    void decrease (Item item, const Prio& value) {
-      int i=_iim[item];
-      _data[i].prio=value;
-      int p=_data[i].parent;
-
-      if( _data[i].left_child && i!=_data[p].child ) {
-        p=_data[p].parent;
-      }
-
-      if ( p!=-1 && _comp(value,_data[p].prio) ) {
-        cut(i,p);
-        if ( _comp(_data[_min].prio,value) ) {
-          fuse(_min,i);
-        } else {
-          fuse(i,_min);
-          _min=i;
-        }
-      }
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param item The item.
-    /// \param value The priority.
-    /// \pre \e item must be stored in the heap with priority at most \e value.
-    void increase (Item item, const Prio& value) {
-      erase(item);
-      push(item,value);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param item The item.
-    State state(const Item &item) const {
-      int i=_iim[item];
-      if( i>=0 ) {
-        if( _data[i].in ) i=0;
-        else i=-2;
-      }
-      return State(i);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-      case POST_HEAP:
-      case PRE_HEAP:
-        if (state(i) == IN_HEAP) erase(i);
-        _iim[i]=st;
-        break;
-      case IN_HEAP:
-        break;
-      }
-    }
-
-  private:
-
-    void cut(int a, int b) {
-      int child_a;
-      switch (_data[a].degree) {
-        case 2:
-          child_a = _data[_data[a].child].parent;
-          if( _data[a].left_child ) {
-            _data[child_a].left_child=true;
-            _data[b].child=child_a;
-            _data[child_a].parent=_data[a].parent;
-          }
-          else {
-            _data[child_a].left_child=false;
-            _data[child_a].parent=b;
-            if( a!=_data[b].child )
-              _data[_data[b].child].parent=child_a;
-            else
-              _data[b].child=child_a;
-          }
-          --_data[a].degree;
-          _data[_data[a].child].parent=a;
-          break;
-
-        case 1:
-          child_a = _data[a].child;
-          if( !_data[child_a].left_child ) {
-            --_data[a].degree;
-            if( _data[a].left_child ) {
-              _data[child_a].left_child=true;
-              _data[child_a].parent=_data[a].parent;
-              _data[b].child=child_a;
-            }
-            else {
-              _data[child_a].left_child=false;
-              _data[child_a].parent=b;
-              if( a!=_data[b].child )
-                _data[_data[b].child].parent=child_a;
-              else
-                _data[b].child=child_a;
-            }
-            _data[a].child=-1;
-          }
-          else {
-            --_data[b].degree;
-            if( _data[a].left_child ) {
-              _data[b].child =
-                (1==_data[b].degree) ? _data[a].parent : -1;
-            } else {
-              if (1==_data[b].degree)
-                _data[_data[b].child].parent=b;
-              else
-                _data[b].child=-1;
-            }
-          }
-          break;
-
-        case 0:
-          --_data[b].degree;
-          if( _data[a].left_child ) {
-            _data[b].child =
-              (0!=_data[b].degree) ? _data[a].parent : -1;
-          } else {
-            if( 0!=_data[b].degree )
-              _data[_data[b].child].parent=b;
-            else
-              _data[b].child=-1;
-          }
-          break;
-      }
-      _data[a].parent=-1;
-      _data[a].left_child=false;
-    }
-
-    void fuse(int a, int b) {
-      int child_a = _data[a].child;
-      int child_b = _data[b].child;
-      _data[a].child=b;
-      _data[b].parent=a;
-      _data[b].left_child=true;
-
-      if( -1!=child_a ) {
-        _data[b].child=child_a;
-        _data[child_a].parent=b;
-        _data[child_a].left_child=false;
-        ++_data[b].degree;
-
-        if( -1!=child_b ) {
-           _data[b].child=child_b;
-           _data[child_b].parent=child_a;
-        }
-      }
-      else { ++_data[a].degree; }
-    }
-
-    class store {
-      friend class PairingHeap;
-
-      Item name;
-      int parent;
-      int child;
-      bool left_child;
-      int degree;
-      bool in;
-      Prio prio;
-
-      store() : parent(-1), child(-1), left_child(false), degree(0), in(true) {}
-    };
-  };
-
-} //namespace lemon
-
-#endif //LEMON_PAIRING_HEAP_H
-
Index: lemon/path.h
===================================================================
--- lemon/path.h	(revision 920)
+++ lemon/path.h	(revision 990)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -44,5 +44,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence, it
+  /// lemon path type stores just this list. As a consequence, it
   /// cannot enumerate the nodes of the path and the source node of
   /// a zero length path is undefined.
@@ -65,4 +65,10 @@
     Path() {}
 
+    /// \brief Copy constructor
+    ///
+    Path(const Path& cpath) {
+      pathCopy(cpath, *this);
+    }
+
     /// \brief Template copy constructor
     ///
@@ -72,4 +78,11 @@
     Path(const CPath& cpath) {
       pathCopy(cpath, *this);
+    }
+
+    /// \brief Copy assignment
+    ///
+    Path& operator=(const Path& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
     }
 
@@ -136,5 +149,5 @@
     void clear() { head.clear(); tail.clear(); }
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -144,5 +157,5 @@
     }
 
-    /// \brief Initialize arc iterator to point to the n-th arc
+    /// \brief Initialize arc iterator to point to the nth arc
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -232,5 +245,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
@@ -253,4 +266,10 @@
     SimplePath() {}
 
+    /// \brief Copy constructor
+    ///
+    SimplePath(const SimplePath& cpath) {
+      pathCopy(cpath, *this);
+    }
+
     /// \brief Template copy constructor
     ///
@@ -260,4 +279,11 @@
     SimplePath(const CPath& cpath) {
       pathCopy(cpath, *this);
+    }
+
+    /// \brief Copy assignment
+    ///
+    SimplePath& operator=(const SimplePath& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
     }
 
@@ -328,5 +354,5 @@
     void clear() { data.clear(); }
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -335,5 +361,5 @@
     }
 
-    /// \brief  Initializes arc iterator to point to the n-th arc.
+    /// \brief  Initializes arc iterator to point to the nth arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -396,5 +422,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot store the source.
@@ -432,4 +458,10 @@
     ListPath() : first(0), last(0) {}
 
+    /// \brief Copy constructor
+    ///
+    ListPath(const ListPath& cpath) : first(0), last(0) {
+      pathCopy(cpath, *this);
+    }
+
     /// \brief Template copy constructor
     ///
@@ -446,4 +478,11 @@
     ~ListPath() {
       clear();
+    }
+
+    /// \brief Copy assignment
+    ///
+    ListPath& operator=(const ListPath& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
     }
 
@@ -505,7 +544,7 @@
     };
 
-    /// \brief The n-th arc.
-    ///
-    /// This function looks for the n-th arc in O(n) time.
+    /// \brief The nth arc.
+    ///
+    /// This function looks for the nth arc in O(n) time.
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
     const Arc& nth(int n) const {
@@ -517,5 +556,5 @@
     }
 
-    /// \brief Initializes arc iterator to point to the n-th arc.
+    /// \brief Initializes arc iterator to point to the nth arc.
     ArcIt nthIt(int n) const {
       Node *node = first;
@@ -736,5 +775,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores just this list. As a consequence it
+  /// lemon path type stores just this list. As a consequence it
   /// cannot enumerate the nodes in the path and the source node of
   /// a zero length path is undefined.
@@ -759,4 +798,10 @@
     StaticPath() : len(0), arcs(0) {}
 
+    /// \brief Copy constructor
+    ///
+    StaticPath(const StaticPath& cpath) : arcs(0) {
+      pathCopy(cpath, *this);
+    }
+
     /// \brief Template copy constructor
     ///
@@ -772,4 +817,11 @@
     ~StaticPath() {
       if (arcs) delete[] arcs;
+    }
+
+    /// \brief Copy assignment
+    ///
+    StaticPath& operator=(const StaticPath& cpath) {
+      pathCopy(cpath, *this);
+      return *this;
     }
 
@@ -832,5 +884,5 @@
     };
 
-    /// \brief The n-th arc.
+    /// \brief The nth arc.
     ///
     /// \pre \c n is in the <tt>[0..length() - 1]</tt> range.
@@ -839,5 +891,5 @@
     }
 
-    /// \brief The arc iterator pointing to the n-th arc.
+    /// \brief The arc iterator pointing to the nth arc.
     ArcIt nthIt(int n) const {
       return ArcIt(*this, n);
@@ -967,5 +1019,5 @@
     };
 
-
+    
     template <typename From, typename To,
               bool revEnable = RevPathTagIndicator<From>::value>
@@ -973,5 +1025,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorForward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -980,5 +1032,5 @@
       static void copy(const From& from, To& to) {
         PathCopySelectorBackward<From, To>::copy(from, to);
-      }
+      }      
     };
 
@@ -1043,5 +1095,5 @@
   ///
   /// In a sense, the path can be treated as a list of arcs. The
-  /// LEMON path type stores only this list. As a consequence, it
+  /// lemon path type stores only this list. As a consequence, it
   /// cannot enumerate the nodes in the path and the zero length paths
   /// cannot have a source node.
Index: mon/planarity.h
===================================================================
--- lemon/planarity.h	(revision 877)
+++ 	(revision )
@@ -1,2755 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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_PLANARITY_H
-#define LEMON_PLANARITY_H
-
-/// \ingroup planar
-/// \file
-/// \brief Planarity checking, embedding, drawing and coloring
-
-#include <vector>
-#include <list>
-
-#include <lemon/dfs.h>
-#include <lemon/bfs.h>
-#include <lemon/radix_sort.h>
-#include <lemon/maps.h>
-#include <lemon/path.h>
-#include <lemon/bucket_heap.h>
-#include <lemon/adaptors.h>
-#include <lemon/edge_set.h>
-#include <lemon/color.h>
-#include <lemon/dim2.h>
-
-namespace lemon {
-
-  namespace _planarity_bits {
-
-    template <typename Graph>
-    struct PlanarityVisitor : DfsVisitor<Graph> {
-
-      TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-      typedef typename Graph::template NodeMap<Arc> PredMap;
-
-      typedef typename Graph::template EdgeMap<bool> TreeMap;
-
-      typedef typename Graph::template NodeMap<int> OrderMap;
-      typedef std::vector<Node> OrderList;
-
-      typedef typename Graph::template NodeMap<int> LowMap;
-      typedef typename Graph::template NodeMap<int> AncestorMap;
-
-      PlanarityVisitor(const Graph& graph,
-                       PredMap& pred_map, TreeMap& tree_map,
-                       OrderMap& order_map, OrderList& order_list,
-                       AncestorMap& ancestor_map, LowMap& low_map)
-        : _graph(graph), _pred_map(pred_map), _tree_map(tree_map),
-          _order_map(order_map), _order_list(order_list),
-          _ancestor_map(ancestor_map), _low_map(low_map) {}
-
-      void reach(const Node& node) {
-        _order_map[node] = _order_list.size();
-        _low_map[node] = _order_list.size();
-        _ancestor_map[node] = _order_list.size();
-        _order_list.push_back(node);
-      }
-
-      void discover(const Arc& arc) {
-        Node source = _graph.source(arc);
-        Node target = _graph.target(arc);
-
-        _tree_map[arc] = true;
-        _pred_map[target] = arc;
-      }
-
-      void examine(const Arc& arc) {
-        Node source = _graph.source(arc);
-        Node target = _graph.target(arc);
-
-        if (_order_map[target] < _order_map[source] && !_tree_map[arc]) {
-          if (_low_map[source] > _order_map[target]) {
-            _low_map[source] = _order_map[target];
-          }
-          if (_ancestor_map[source] > _order_map[target]) {
-            _ancestor_map[source] = _order_map[target];
-          }
-        }
-      }
-
-      void backtrack(const Arc& arc) {
-        Node source = _graph.source(arc);
-        Node target = _graph.target(arc);
-
-        if (_low_map[source] > _low_map[target]) {
-          _low_map[source] = _low_map[target];
-        }
-      }
-
-      const Graph& _graph;
-      PredMap& _pred_map;
-      TreeMap& _tree_map;
-      OrderMap& _order_map;
-      OrderList& _order_list;
-      AncestorMap& _ancestor_map;
-      LowMap& _low_map;
-    };
-
-    template <typename Graph, bool embedding = true>
-    struct NodeDataNode {
-      int prev, next;
-      int visited;
-      typename Graph::Arc first;
-      bool inverted;
-    };
-
-    template <typename Graph>
-    struct NodeDataNode<Graph, false> {
-      int prev, next;
-      int visited;
-    };
-
-    template <typename Graph>
-    struct ChildListNode {
-      typedef typename Graph::Node Node;
-      Node first;
-      Node prev, next;
-    };
-
-    template <typename Graph>
-    struct ArcListNode {
-      typename Graph::Arc prev, next;
-    };
-
-    template <typename Graph>
-    class PlanarityChecking {
-    private:
-
-      TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-      const Graph& _graph;
-
-    private:
-
-      typedef typename Graph::template NodeMap<Arc> PredMap;
-
-      typedef typename Graph::template EdgeMap<bool> TreeMap;
-
-      typedef typename Graph::template NodeMap<int> OrderMap;
-      typedef std::vector<Node> OrderList;
-
-      typedef typename Graph::template NodeMap<int> LowMap;
-      typedef typename Graph::template NodeMap<int> AncestorMap;
-
-      typedef _planarity_bits::NodeDataNode<Graph> NodeDataNode;
-      typedef std::vector<NodeDataNode> NodeData;
-
-      typedef _planarity_bits::ChildListNode<Graph> ChildListNode;
-      typedef typename Graph::template NodeMap<ChildListNode> ChildLists;
-
-      typedef typename Graph::template NodeMap<std::list<int> > MergeRoots;
-
-      typedef typename Graph::template NodeMap<bool> EmbedArc;
-
-    public:
-
-      PlanarityChecking(const Graph& graph) : _graph(graph) {}
-
-      bool run() {
-        typedef _planarity_bits::PlanarityVisitor<Graph> Visitor;
-
-        PredMap pred_map(_graph, INVALID);
-        TreeMap tree_map(_graph, false);
-
-        OrderMap order_map(_graph, -1);
-        OrderList order_list;
-
-        AncestorMap ancestor_map(_graph, -1);
-        LowMap low_map(_graph, -1);
-
-        Visitor visitor(_graph, pred_map, tree_map,
-                        order_map, order_list, ancestor_map, low_map);
-        DfsVisit<Graph, Visitor> visit(_graph, visitor);
-        visit.run();
-
-        ChildLists child_lists(_graph);
-        createChildLists(tree_map, order_map, low_map, child_lists);
-
-        NodeData node_data(2 * order_list.size());
-
-        EmbedArc embed_arc(_graph, false);
-
-        MergeRoots merge_roots(_graph);
-
-        for (int i = order_list.size() - 1; i >= 0; --i) {
-
-          Node node = order_list[i];
-
-          Node source = node;
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && tree_map[e]) {
-              initFace(target, node_data, order_map, order_list);
-            }
-          }
-
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && !tree_map[e]) {
-              embed_arc[target] = true;
-              walkUp(target, source, i, pred_map, low_map,
-                     order_map, order_list, node_data, merge_roots);
-            }
-          }
-
-          for (typename MergeRoots::Value::iterator it =
-                 merge_roots[node].begin();
-               it != merge_roots[node].end(); ++it) {
-            int rn = *it;
-            walkDown(rn, i, node_data, order_list, child_lists,
-                     ancestor_map, low_map, embed_arc, merge_roots);
-          }
-          merge_roots[node].clear();
-
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && !tree_map[e]) {
-              if (embed_arc[target]) {
-                return false;
-              }
-            }
-          }
-        }
-
-        return true;
-      }
-
-    private:
-
-      void createChildLists(const TreeMap& tree_map, const OrderMap& order_map,
-                            const LowMap& low_map, ChildLists& child_lists) {
-
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          Node source = n;
-
-          std::vector<Node> targets;
-          for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-            Node target = _graph.target(e);
-
-            if (order_map[source] < order_map[target] && tree_map[e]) {
-              targets.push_back(target);
-            }
-          }
-
-          if (targets.size() == 0) {
-            child_lists[source].first = INVALID;
-          } else if (targets.size() == 1) {
-            child_lists[source].first = targets[0];
-            child_lists[targets[0]].prev = INVALID;
-            child_lists[targets[0]].next = INVALID;
-          } else {
-            radixSort(targets.begin(), targets.end(), mapToFunctor(low_map));
-            for (int i = 1; i < int(targets.size()); ++i) {
-              child_lists[targets[i]].prev = targets[i - 1];
-              child_lists[targets[i - 1]].next = targets[i];
-            }
-            child_lists[targets.back()].next = INVALID;
-            child_lists[targets.front()].prev = INVALID;
-            child_lists[source].first = targets.front();
-          }
-        }
-      }
-
-      void walkUp(const Node& node, Node root, int rorder,
-                  const PredMap& pred_map, const LowMap& low_map,
-                  const OrderMap& order_map, const OrderList& order_list,
-                  NodeData& node_data, MergeRoots& merge_roots) {
-
-        int na, nb;
-        bool da, db;
-
-        na = nb = order_map[node];
-        da = true; db = false;
-
-        while (true) {
-
-          if (node_data[na].visited == rorder) break;
-          if (node_data[nb].visited == rorder) break;
-
-          node_data[na].visited = rorder;
-          node_data[nb].visited = rorder;
-
-          int rn = -1;
-
-          if (na >= int(order_list.size())) {
-            rn = na;
-          } else if (nb >= int(order_list.size())) {
-            rn = nb;
-          }
-
-          if (rn == -1) {
-            int nn;
-
-            nn = da ? node_data[na].prev : node_data[na].next;
-            da = node_data[nn].prev != na;
-            na = nn;
-
-            nn = db ? node_data[nb].prev : node_data[nb].next;
-            db = node_data[nn].prev != nb;
-            nb = nn;
-
-          } else {
-
-            Node rep = order_list[rn - order_list.size()];
-            Node parent = _graph.source(pred_map[rep]);
-
-            if (low_map[rep] < rorder) {
-              merge_roots[parent].push_back(rn);
-            } else {
-              merge_roots[parent].push_front(rn);
-            }
-
-            if (parent != root) {
-              na = nb = order_map[parent];
-              da = true; db = false;
-            } else {
-              break;
-            }
-          }
-        }
-      }
-
-      void walkDown(int rn, int rorder, NodeData& node_data,
-                    OrderList& order_list, ChildLists& child_lists,
-                    AncestorMap& ancestor_map, LowMap& low_map,
-                    EmbedArc& embed_arc, MergeRoots& merge_roots) {
-
-        std::vector<std::pair<int, bool> > merge_stack;
-
-        for (int di = 0; di < 2; ++di) {
-          bool rd = di == 0;
-          int pn = rn;
-          int n = rd ? node_data[rn].next : node_data[rn].prev;
-
-          while (n != rn) {
-
-            Node node = order_list[n];
-
-            if (embed_arc[node]) {
-
-              // Merging components on the critical path
-              while (!merge_stack.empty()) {
-
-                // Component root
-                int cn = merge_stack.back().first;
-                bool cd = merge_stack.back().second;
-                merge_stack.pop_back();
-
-                // Parent of component
-                int dn = merge_stack.back().first;
-                bool dd = merge_stack.back().second;
-                merge_stack.pop_back();
-
-                Node parent = order_list[dn];
-
-                // Erasing from merge_roots
-                merge_roots[parent].pop_front();
-
-                Node child = order_list[cn - order_list.size()];
-
-                // Erasing from child_lists
-                if (child_lists[child].prev != INVALID) {
-                  child_lists[child_lists[child].prev].next =
-                    child_lists[child].next;
-                } else {
-                  child_lists[parent].first = child_lists[child].next;
-                }
-
-                if (child_lists[child].next != INVALID) {
-                  child_lists[child_lists[child].next].prev =
-                    child_lists[child].prev;
-                }
-
-                // Merging external faces
-                {
-                  int en = cn;
-                  cn = cd ? node_data[cn].prev : node_data[cn].next;
-                  cd = node_data[cn].next == en;
-
-                }
-
-                if (cd) node_data[cn].next = dn; else node_data[cn].prev = dn;
-                if (dd) node_data[dn].prev = cn; else node_data[dn].next = cn;
-
-              }
-
-              bool d = pn == node_data[n].prev;
-
-              if (node_data[n].prev == node_data[n].next &&
-                  node_data[n].inverted) {
-                d = !d;
-              }
-
-              // Embedding arc into external face
-              if (rd) node_data[rn].next = n; else node_data[rn].prev = n;
-              if (d) node_data[n].prev = rn; else node_data[n].next = rn;
-              pn = rn;
-
-              embed_arc[order_list[n]] = false;
-            }
-
-            if (!merge_roots[node].empty()) {
-
-              bool d = pn == node_data[n].prev;
-
-              merge_stack.push_back(std::make_pair(n, d));
-
-              int rn = merge_roots[node].front();
-
-              int xn = node_data[rn].next;
-              Node xnode = order_list[xn];
-
-              int yn = node_data[rn].prev;
-              Node ynode = order_list[yn];
-
-              bool rd;
-              if (!external(xnode, rorder, child_lists,
-                            ancestor_map, low_map)) {
-                rd = true;
-              } else if (!external(ynode, rorder, child_lists,
-                                   ancestor_map, low_map)) {
-                rd = false;
-              } else if (pertinent(xnode, embed_arc, merge_roots)) {
-                rd = true;
-              } else {
-                rd = false;
-              }
-
-              merge_stack.push_back(std::make_pair(rn, rd));
-
-              pn = rn;
-              n = rd ? xn : yn;
-
-            } else if (!external(node, rorder, child_lists,
-                                 ancestor_map, low_map)) {
-              int nn = (node_data[n].next != pn ?
-                        node_data[n].next : node_data[n].prev);
-
-              bool nd = n == node_data[nn].prev;
-
-              if (nd) node_data[nn].prev = pn;
-              else node_data[nn].next = pn;
-
-              if (n == node_data[pn].prev) node_data[pn].prev = nn;
-              else node_data[pn].next = nn;
-
-              node_data[nn].inverted =
-                (node_data[nn].prev == node_data[nn].next && nd != rd);
-
-              n = nn;
-            }
-            else break;
-
-          }
-
-          if (!merge_stack.empty() || n == rn) {
-            break;
-          }
-        }
-      }
-
-      void initFace(const Node& node, NodeData& node_data,
-                    const OrderMap& order_map, const OrderList& order_list) {
-        int n = order_map[node];
-        int rn = n + order_list.size();
-
-        node_data[n].next = node_data[n].prev = rn;
-        node_data[rn].next = node_data[rn].prev = n;
-
-        node_data[n].visited = order_list.size();
-        node_data[rn].visited = order_list.size();
-
-      }
-
-      bool external(const Node& node, int rorder,
-                    ChildLists& child_lists, AncestorMap& ancestor_map,
-                    LowMap& low_map) {
-        Node child = child_lists[node].first;
-
-        if (child != INVALID) {
-          if (low_map[child] < rorder) return true;
-        }
-
-        if (ancestor_map[node] < rorder) return true;
-
-        return false;
-      }
-
-      bool pertinent(const Node& node, const EmbedArc& embed_arc,
-                     const MergeRoots& merge_roots) {
-        return !merge_roots[node].empty() || embed_arc[node];
-      }
-
-    };
-
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Planarity checking of an undirected simple graph
-  ///
-  /// This function implements the Boyer-Myrvold algorithm for
-  /// planarity checking of an undirected simple graph. It is a simplified
-  /// version of the PlanarEmbedding algorithm class because neither
-  /// the embedding nor the Kuratowski subdivisons are computed.
-  template <typename GR>
-  bool checkPlanarity(const GR& graph) {
-    _planarity_bits::PlanarityChecking<GR> pc(graph);
-    return pc.run();
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Planar embedding of an undirected simple graph
-  ///
-  /// This class implements the Boyer-Myrvold algorithm for planar
-  /// embedding of an undirected simple graph. The planar embedding is an
-  /// ordering of the outgoing edges of the nodes, which is a possible
-  /// configuration to draw the graph in the plane. If there is not
-  /// such ordering then the graph contains a K<sub>5</sub> (full graph
-  /// with 5 nodes) or a K<sub>3,3</sub> (complete bipartite graph on
-  /// 3 Red and 3 Blue nodes) subdivision.
-  ///
-  /// The current implementation calculates either an embedding or a
-  /// Kuratowski subdivision. The running time of the algorithm is O(n).
-  ///
-  /// \see PlanarDrawing, checkPlanarity()
-  template <typename Graph>
-  class PlanarEmbedding {
-  private:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    const Graph& _graph;
-    typename Graph::template ArcMap<Arc> _embedding;
-
-    typename Graph::template EdgeMap<bool> _kuratowski;
-
-  private:
-
-    typedef typename Graph::template NodeMap<Arc> PredMap;
-
-    typedef typename Graph::template EdgeMap<bool> TreeMap;
-
-    typedef typename Graph::template NodeMap<int> OrderMap;
-    typedef std::vector<Node> OrderList;
-
-    typedef typename Graph::template NodeMap<int> LowMap;
-    typedef typename Graph::template NodeMap<int> AncestorMap;
-
-    typedef _planarity_bits::NodeDataNode<Graph> NodeDataNode;
-    typedef std::vector<NodeDataNode> NodeData;
-
-    typedef _planarity_bits::ChildListNode<Graph> ChildListNode;
-    typedef typename Graph::template NodeMap<ChildListNode> ChildLists;
-
-    typedef typename Graph::template NodeMap<std::list<int> > MergeRoots;
-
-    typedef typename Graph::template NodeMap<Arc> EmbedArc;
-
-    typedef _planarity_bits::ArcListNode<Graph> ArcListNode;
-    typedef typename Graph::template ArcMap<ArcListNode> ArcLists;
-
-    typedef typename Graph::template NodeMap<bool> FlipMap;
-
-    typedef typename Graph::template NodeMap<int> TypeMap;
-
-    enum IsolatorNodeType {
-      HIGHX = 6, LOWX = 7,
-      HIGHY = 8, LOWY = 9,
-      ROOT = 10, PERTINENT = 11,
-      INTERNAL = 12
-    };
-
-  public:
-
-    /// \brief The map type for storing the embedding
-    ///
-    /// The map type for storing the embedding.
-    /// \see embeddingMap()
-    typedef typename Graph::template ArcMap<Arc> EmbeddingMap;
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
-    PlanarEmbedding(const Graph& graph)
-      : _graph(graph), _embedding(_graph), _kuratowski(graph, false) {}
-
-    /// \brief Run the algorithm.
-    ///
-    /// This function runs the algorithm.
-    /// \param kuratowski If this parameter is set to \c false, then the
-    /// algorithm does not compute a Kuratowski subdivision.
-    /// \return \c true if the graph is planar.
-    bool run(bool kuratowski = true) {
-      typedef _planarity_bits::PlanarityVisitor<Graph> Visitor;
-
-      PredMap pred_map(_graph, INVALID);
-      TreeMap tree_map(_graph, false);
-
-      OrderMap order_map(_graph, -1);
-      OrderList order_list;
-
-      AncestorMap ancestor_map(_graph, -1);
-      LowMap low_map(_graph, -1);
-
-      Visitor visitor(_graph, pred_map, tree_map,
-                      order_map, order_list, ancestor_map, low_map);
-      DfsVisit<Graph, Visitor> visit(_graph, visitor);
-      visit.run();
-
-      ChildLists child_lists(_graph);
-      createChildLists(tree_map, order_map, low_map, child_lists);
-
-      NodeData node_data(2 * order_list.size());
-
-      EmbedArc embed_arc(_graph, INVALID);
-
-      MergeRoots merge_roots(_graph);
-
-      ArcLists arc_lists(_graph);
-
-      FlipMap flip_map(_graph, false);
-
-      for (int i = order_list.size() - 1; i >= 0; --i) {
-
-        Node node = order_list[i];
-
-        node_data[i].first = INVALID;
-
-        Node source = node;
-        for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && tree_map[e]) {
-            initFace(target, arc_lists, node_data,
-                     pred_map, order_map, order_list);
-          }
-        }
-
-        for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && !tree_map[e]) {
-            embed_arc[target] = e;
-            walkUp(target, source, i, pred_map, low_map,
-                   order_map, order_list, node_data, merge_roots);
-          }
-        }
-
-        for (typename MergeRoots::Value::iterator it =
-               merge_roots[node].begin(); it != merge_roots[node].end(); ++it) {
-          int rn = *it;
-          walkDown(rn, i, node_data, arc_lists, flip_map, order_list,
-                   child_lists, ancestor_map, low_map, embed_arc, merge_roots);
-        }
-        merge_roots[node].clear();
-
-        for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && !tree_map[e]) {
-            if (embed_arc[target] != INVALID) {
-              if (kuratowski) {
-                isolateKuratowski(e, node_data, arc_lists, flip_map,
-                                  order_map, order_list, pred_map, child_lists,
-                                  ancestor_map, low_map,
-                                  embed_arc, merge_roots);
-              }
-              return false;
-            }
-          }
-        }
-      }
-
-      for (int i = 0; i < int(order_list.size()); ++i) {
-
-        mergeRemainingFaces(order_list[i], node_data, order_list, order_map,
-                            child_lists, arc_lists);
-        storeEmbedding(order_list[i], node_data, order_map, pred_map,
-                       arc_lists, flip_map);
-      }
-
-      return true;
-    }
-
-    /// \brief Give back the successor of an arc
-    ///
-    /// This function gives back the successor of an arc. It makes
-    /// possible to query the cyclic order of the outgoing arcs from
-    /// a node.
-    Arc next(const Arc& arc) const {
-      return _embedding[arc];
-    }
-
-    /// \brief Give back the calculated embedding map
-    ///
-    /// This function gives back the calculated embedding map, which
-    /// contains the successor of each arc in the cyclic order of the
-    /// outgoing arcs of its source node.
-    const EmbeddingMap& embeddingMap() const {
-      return _embedding;
-    }
-
-    /// \brief Give back \c true if the given edge is in the Kuratowski
-    /// subdivision
-    ///
-    /// This function gives back \c true if the given edge is in the found
-    /// Kuratowski subdivision.
-    /// \pre The \c run() function must be called with \c true parameter
-    /// before using this function.
-    bool kuratowski(const Edge& edge) const {
-      return _kuratowski[edge];
-    }
-
-  private:
-
-    void createChildLists(const TreeMap& tree_map, const OrderMap& order_map,
-                          const LowMap& low_map, ChildLists& child_lists) {
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        Node source = n;
-
-        std::vector<Node> targets;
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node target = _graph.target(e);
-
-          if (order_map[source] < order_map[target] && tree_map[e]) {
-            targets.push_back(target);
-          }
-        }
-
-        if (targets.size() == 0) {
-          child_lists[source].first = INVALID;
-        } else if (targets.size() == 1) {
-          child_lists[source].first = targets[0];
-          child_lists[targets[0]].prev = INVALID;
-          child_lists[targets[0]].next = INVALID;
-        } else {
-          radixSort(targets.begin(), targets.end(), mapToFunctor(low_map));
-          for (int i = 1; i < int(targets.size()); ++i) {
-            child_lists[targets[i]].prev = targets[i - 1];
-            child_lists[targets[i - 1]].next = targets[i];
-          }
-          child_lists[targets.back()].next = INVALID;
-          child_lists[targets.front()].prev = INVALID;
-          child_lists[source].first = targets.front();
-        }
-      }
-    }
-
-    void walkUp(const Node& node, Node root, int rorder,
-                const PredMap& pred_map, const LowMap& low_map,
-                const OrderMap& order_map, const OrderList& order_list,
-                NodeData& node_data, MergeRoots& merge_roots) {
-
-      int na, nb;
-      bool da, db;
-
-      na = nb = order_map[node];
-      da = true; db = false;
-
-      while (true) {
-
-        if (node_data[na].visited == rorder) break;
-        if (node_data[nb].visited == rorder) break;
-
-        node_data[na].visited = rorder;
-        node_data[nb].visited = rorder;
-
-        int rn = -1;
-
-        if (na >= int(order_list.size())) {
-          rn = na;
-        } else if (nb >= int(order_list.size())) {
-          rn = nb;
-        }
-
-        if (rn == -1) {
-          int nn;
-
-          nn = da ? node_data[na].prev : node_data[na].next;
-          da = node_data[nn].prev != na;
-          na = nn;
-
-          nn = db ? node_data[nb].prev : node_data[nb].next;
-          db = node_data[nn].prev != nb;
-          nb = nn;
-
-        } else {
-
-          Node rep = order_list[rn - order_list.size()];
-          Node parent = _graph.source(pred_map[rep]);
-
-          if (low_map[rep] < rorder) {
-            merge_roots[parent].push_back(rn);
-          } else {
-            merge_roots[parent].push_front(rn);
-          }
-
-          if (parent != root) {
-            na = nb = order_map[parent];
-            da = true; db = false;
-          } else {
-            break;
-          }
-        }
-      }
-    }
-
-    void walkDown(int rn, int rorder, NodeData& node_data,
-                  ArcLists& arc_lists, FlipMap& flip_map,
-                  OrderList& order_list, ChildLists& child_lists,
-                  AncestorMap& ancestor_map, LowMap& low_map,
-                  EmbedArc& embed_arc, MergeRoots& merge_roots) {
-
-      std::vector<std::pair<int, bool> > merge_stack;
-
-      for (int di = 0; di < 2; ++di) {
-        bool rd = di == 0;
-        int pn = rn;
-        int n = rd ? node_data[rn].next : node_data[rn].prev;
-
-        while (n != rn) {
-
-          Node node = order_list[n];
-
-          if (embed_arc[node] != INVALID) {
-
-            // Merging components on the critical path
-            while (!merge_stack.empty()) {
-
-              // Component root
-              int cn = merge_stack.back().first;
-              bool cd = merge_stack.back().second;
-              merge_stack.pop_back();
-
-              // Parent of component
-              int dn = merge_stack.back().first;
-              bool dd = merge_stack.back().second;
-              merge_stack.pop_back();
-
-              Node parent = order_list[dn];
-
-              // Erasing from merge_roots
-              merge_roots[parent].pop_front();
-
-              Node child = order_list[cn - order_list.size()];
-
-              // Erasing from child_lists
-              if (child_lists[child].prev != INVALID) {
-                child_lists[child_lists[child].prev].next =
-                  child_lists[child].next;
-              } else {
-                child_lists[parent].first = child_lists[child].next;
-              }
-
-              if (child_lists[child].next != INVALID) {
-                child_lists[child_lists[child].next].prev =
-                  child_lists[child].prev;
-              }
-
-              // Merging arcs + flipping
-              Arc de = node_data[dn].first;
-              Arc ce = node_data[cn].first;
-
-              flip_map[order_list[cn - order_list.size()]] = cd != dd;
-              if (cd != dd) {
-                std::swap(arc_lists[ce].prev, arc_lists[ce].next);
-                ce = arc_lists[ce].prev;
-                std::swap(arc_lists[ce].prev, arc_lists[ce].next);
-              }
-
-              {
-                Arc dne = arc_lists[de].next;
-                Arc cne = arc_lists[ce].next;
-
-                arc_lists[de].next = cne;
-                arc_lists[ce].next = dne;
-
-                arc_lists[dne].prev = ce;
-                arc_lists[cne].prev = de;
-              }
-
-              if (dd) {
-                node_data[dn].first = ce;
-              }
-
-              // Merging external faces
-              {
-                int en = cn;
-                cn = cd ? node_data[cn].prev : node_data[cn].next;
-                cd = node_data[cn].next == en;
-
-                 if (node_data[cn].prev == node_data[cn].next &&
-                    node_data[cn].inverted) {
-                   cd = !cd;
-                 }
-              }
-
-              if (cd) node_data[cn].next = dn; else node_data[cn].prev = dn;
-              if (dd) node_data[dn].prev = cn; else node_data[dn].next = cn;
-
-            }
-
-            bool d = pn == node_data[n].prev;
-
-            if (node_data[n].prev == node_data[n].next &&
-                node_data[n].inverted) {
-              d = !d;
-            }
-
-            // Add new arc
-            {
-              Arc arc = embed_arc[node];
-              Arc re = node_data[rn].first;
-
-              arc_lists[arc_lists[re].next].prev = arc;
-              arc_lists[arc].next = arc_lists[re].next;
-              arc_lists[arc].prev = re;
-              arc_lists[re].next = arc;
-
-              if (!rd) {
-                node_data[rn].first = arc;
-              }
-
-              Arc rev = _graph.oppositeArc(arc);
-              Arc e = node_data[n].first;
-
-              arc_lists[arc_lists[e].next].prev = rev;
-              arc_lists[rev].next = arc_lists[e].next;
-              arc_lists[rev].prev = e;
-              arc_lists[e].next = rev;
-
-              if (d) {
-                node_data[n].first = rev;
-              }
-
-            }
-
-            // Embedding arc into external face
-            if (rd) node_data[rn].next = n; else node_data[rn].prev = n;
-            if (d) node_data[n].prev = rn; else node_data[n].next = rn;
-            pn = rn;
-
-            embed_arc[order_list[n]] = INVALID;
-          }
-
-          if (!merge_roots[node].empty()) {
-
-            bool d = pn == node_data[n].prev;
-            if (node_data[n].prev == node_data[n].next &&
-                node_data[n].inverted) {
-              d = !d;
-            }
-
-            merge_stack.push_back(std::make_pair(n, d));
-
-            int rn = merge_roots[node].front();
-
-            int xn = node_data[rn].next;
-            Node xnode = order_list[xn];
-
-            int yn = node_data[rn].prev;
-            Node ynode = order_list[yn];
-
-            bool rd;
-            if (!external(xnode, rorder, child_lists, ancestor_map, low_map)) {
-              rd = true;
-            } else if (!external(ynode, rorder, child_lists,
-                                 ancestor_map, low_map)) {
-              rd = false;
-            } else if (pertinent(xnode, embed_arc, merge_roots)) {
-              rd = true;
-            } else {
-              rd = false;
-            }
-
-            merge_stack.push_back(std::make_pair(rn, rd));
-
-            pn = rn;
-            n = rd ? xn : yn;
-
-          } else if (!external(node, rorder, child_lists,
-                               ancestor_map, low_map)) {
-            int nn = (node_data[n].next != pn ?
-                      node_data[n].next : node_data[n].prev);
-
-            bool nd = n == node_data[nn].prev;
-
-            if (nd) node_data[nn].prev = pn;
-            else node_data[nn].next = pn;
-
-            if (n == node_data[pn].prev) node_data[pn].prev = nn;
-            else node_data[pn].next = nn;
-
-            node_data[nn].inverted =
-              (node_data[nn].prev == node_data[nn].next && nd != rd);
-
-            n = nn;
-          }
-          else break;
-
-        }
-
-        if (!merge_stack.empty() || n == rn) {
-          break;
-        }
-      }
-    }
-
-    void initFace(const Node& node, ArcLists& arc_lists,
-                  NodeData& node_data, const PredMap& pred_map,
-                  const OrderMap& order_map, const OrderList& order_list) {
-      int n = order_map[node];
-      int rn = n + order_list.size();
-
-      node_data[n].next = node_data[n].prev = rn;
-      node_data[rn].next = node_data[rn].prev = n;
-
-      node_data[n].visited = order_list.size();
-      node_data[rn].visited = order_list.size();
-
-      node_data[n].inverted = false;
-      node_data[rn].inverted = false;
-
-      Arc arc = pred_map[node];
-      Arc rev = _graph.oppositeArc(arc);
-
-      node_data[rn].first = arc;
-      node_data[n].first = rev;
-
-      arc_lists[arc].prev = arc;
-      arc_lists[arc].next = arc;
-
-      arc_lists[rev].prev = rev;
-      arc_lists[rev].next = rev;
-
-    }
-
-    void mergeRemainingFaces(const Node& node, NodeData& node_data,
-                             OrderList& order_list, OrderMap& order_map,
-                             ChildLists& child_lists, ArcLists& arc_lists) {
-      while (child_lists[node].first != INVALID) {
-        int dd = order_map[node];
-        Node child = child_lists[node].first;
-        int cd = order_map[child] + order_list.size();
-        child_lists[node].first = child_lists[child].next;
-
-        Arc de = node_data[dd].first;
-        Arc ce = node_data[cd].first;
-
-        if (de != INVALID) {
-          Arc dne = arc_lists[de].next;
-          Arc cne = arc_lists[ce].next;
-
-          arc_lists[de].next = cne;
-          arc_lists[ce].next = dne;
-
-          arc_lists[dne].prev = ce;
-          arc_lists[cne].prev = de;
-        }
-
-        node_data[dd].first = ce;
-
-      }
-    }
-
-    void storeEmbedding(const Node& node, NodeData& node_data,
-                        OrderMap& order_map, PredMap& pred_map,
-                        ArcLists& arc_lists, FlipMap& flip_map) {
-
-      if (node_data[order_map[node]].first == INVALID) return;
-
-      if (pred_map[node] != INVALID) {
-        Node source = _graph.source(pred_map[node]);
-        flip_map[node] = flip_map[node] != flip_map[source];
-      }
-
-      Arc first = node_data[order_map[node]].first;
-      Arc prev = first;
-
-      Arc arc = flip_map[node] ?
-        arc_lists[prev].prev : arc_lists[prev].next;
-
-      _embedding[prev] = arc;
-
-      while (arc != first) {
-        Arc next = arc_lists[arc].prev == prev ?
-          arc_lists[arc].next : arc_lists[arc].prev;
-        prev = arc; arc = next;
-        _embedding[prev] = arc;
-      }
-    }
-
-
-    bool external(const Node& node, int rorder,
-                  ChildLists& child_lists, AncestorMap& ancestor_map,
-                  LowMap& low_map) {
-      Node child = child_lists[node].first;
-
-      if (child != INVALID) {
-        if (low_map[child] < rorder) return true;
-      }
-
-      if (ancestor_map[node] < rorder) return true;
-
-      return false;
-    }
-
-    bool pertinent(const Node& node, const EmbedArc& embed_arc,
-                   const MergeRoots& merge_roots) {
-      return !merge_roots[node].empty() || embed_arc[node] != INVALID;
-    }
-
-    int lowPoint(const Node& node, OrderMap& order_map, ChildLists& child_lists,
-                 AncestorMap& ancestor_map, LowMap& low_map) {
-      int low_point;
-
-      Node child = child_lists[node].first;
-
-      if (child != INVALID) {
-        low_point = low_map[child];
-      } else {
-        low_point = order_map[node];
-      }
-
-      if (low_point > ancestor_map[node]) {
-        low_point = ancestor_map[node];
-      }
-
-      return low_point;
-    }
-
-    int findComponentRoot(Node root, Node node, ChildLists& child_lists,
-                          OrderMap& order_map, OrderList& order_list) {
-
-      int order = order_map[root];
-      int norder = order_map[node];
-
-      Node child = child_lists[root].first;
-      while (child != INVALID) {
-        int corder = order_map[child];
-        if (corder > order && corder < norder) {
-          order = corder;
-        }
-        child = child_lists[child].next;
-      }
-      return order + order_list.size();
-    }
-
-    Node findPertinent(Node node, OrderMap& order_map, NodeData& node_data,
-                       EmbedArc& embed_arc, MergeRoots& merge_roots) {
-      Node wnode =_graph.target(node_data[order_map[node]].first);
-      while (!pertinent(wnode, embed_arc, merge_roots)) {
-        wnode = _graph.target(node_data[order_map[wnode]].first);
-      }
-      return wnode;
-    }
-
-
-    Node findExternal(Node node, int rorder, OrderMap& order_map,
-                      ChildLists& child_lists, AncestorMap& ancestor_map,
-                      LowMap& low_map, NodeData& node_data) {
-      Node wnode =_graph.target(node_data[order_map[node]].first);
-      while (!external(wnode, rorder, child_lists, ancestor_map, low_map)) {
-        wnode = _graph.target(node_data[order_map[wnode]].first);
-      }
-      return wnode;
-    }
-
-    void markCommonPath(Node node, int rorder, Node& wnode, Node& znode,
-                        OrderList& order_list, OrderMap& order_map,
-                        NodeData& node_data, ArcLists& arc_lists,
-                        EmbedArc& embed_arc, MergeRoots& merge_roots,
-                        ChildLists& child_lists, AncestorMap& ancestor_map,
-                        LowMap& low_map) {
-
-      Node cnode = node;
-      Node pred = INVALID;
-
-      while (true) {
-
-        bool pert = pertinent(cnode, embed_arc, merge_roots);
-        bool ext = external(cnode, rorder, child_lists, ancestor_map, low_map);
-
-        if (pert && ext) {
-          if (!merge_roots[cnode].empty()) {
-            int cn = merge_roots[cnode].back();
-
-            if (low_map[order_list[cn - order_list.size()]] < rorder) {
-              Arc arc = node_data[cn].first;
-              _kuratowski.set(arc, true);
-
-              pred = cnode;
-              cnode = _graph.target(arc);
-
-              continue;
-            }
-          }
-          wnode = znode = cnode;
-          return;
-
-        } else if (pert) {
-          wnode = cnode;
-
-          while (!external(cnode, rorder, child_lists, ancestor_map, low_map)) {
-            Arc arc = node_data[order_map[cnode]].first;
-
-            if (_graph.target(arc) == pred) {
-              arc = arc_lists[arc].next;
-            }
-            _kuratowski.set(arc, true);
-
-            Node next = _graph.target(arc);
-            pred = cnode; cnode = next;
-          }
-
-          znode = cnode;
-          return;
-
-        } else if (ext) {
-          znode = cnode;
-
-          while (!pertinent(cnode, embed_arc, merge_roots)) {
-            Arc arc = node_data[order_map[cnode]].first;
-
-            if (_graph.target(arc) == pred) {
-              arc = arc_lists[arc].next;
-            }
-            _kuratowski.set(arc, true);
-
-            Node next = _graph.target(arc);
-            pred = cnode; cnode = next;
-          }
-
-          wnode = cnode;
-          return;
-
-        } else {
-          Arc arc = node_data[order_map[cnode]].first;
-
-          if (_graph.target(arc) == pred) {
-            arc = arc_lists[arc].next;
-          }
-          _kuratowski.set(arc, true);
-
-          Node next = _graph.target(arc);
-          pred = cnode; cnode = next;
-        }
-
-      }
-
-    }
-
-    void orientComponent(Node root, int rn, OrderMap& order_map,
-                         PredMap& pred_map, NodeData& node_data,
-                         ArcLists& arc_lists, FlipMap& flip_map,
-                         TypeMap& type_map) {
-      node_data[order_map[root]].first = node_data[rn].first;
-      type_map[root] = 1;
-
-      std::vector<Node> st, qu;
-
-      st.push_back(root);
-      while (!st.empty()) {
-        Node node = st.back();
-        st.pop_back();
-        qu.push_back(node);
-
-        Arc arc = node_data[order_map[node]].first;
-
-        if (type_map[_graph.target(arc)] == 0) {
-          st.push_back(_graph.target(arc));
-          type_map[_graph.target(arc)] = 1;
-        }
-
-        Arc last = arc, pred = arc;
-        arc = arc_lists[arc].next;
-        while (arc != last) {
-
-          if (type_map[_graph.target(arc)] == 0) {
-            st.push_back(_graph.target(arc));
-            type_map[_graph.target(arc)] = 1;
-          }
-
-          Arc next = arc_lists[arc].next != pred ?
-            arc_lists[arc].next : arc_lists[arc].prev;
-          pred = arc; arc = next;
-        }
-
-      }
-
-      type_map[root] = 2;
-      flip_map[root] = false;
-
-      for (int i = 1; i < int(qu.size()); ++i) {
-
-        Node node = qu[i];
-
-        while (type_map[node] != 2) {
-          st.push_back(node);
-          type_map[node] = 2;
-          node = _graph.source(pred_map[node]);
-        }
-
-        bool flip = flip_map[node];
-
-        while (!st.empty()) {
-          node = st.back();
-          st.pop_back();
-
-          flip_map[node] = flip != flip_map[node];
-          flip = flip_map[node];
-
-          if (flip) {
-            Arc arc = node_data[order_map[node]].first;
-            std::swap(arc_lists[arc].prev, arc_lists[arc].next);
-            arc = arc_lists[arc].prev;
-            std::swap(arc_lists[arc].prev, arc_lists[arc].next);
-            node_data[order_map[node]].first = arc;
-          }
-        }
-      }
-
-      for (int i = 0; i < int(qu.size()); ++i) {
-
-        Arc arc = node_data[order_map[qu[i]]].first;
-        Arc last = arc, pred = arc;
-
-        arc = arc_lists[arc].next;
-        while (arc != last) {
-
-          if (arc_lists[arc].next == pred) {
-            std::swap(arc_lists[arc].next, arc_lists[arc].prev);
-          }
-          pred = arc; arc = arc_lists[arc].next;
-        }
-
-      }
-    }
-
-    void setFaceFlags(Node root, Node wnode, Node ynode, Node xnode,
-                      OrderMap& order_map, NodeData& node_data,
-                      TypeMap& type_map) {
-      Node node = _graph.target(node_data[order_map[root]].first);
-
-      while (node != ynode) {
-        type_map[node] = HIGHY;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-
-      while (node != wnode) {
-        type_map[node] = LOWY;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-
-      node = _graph.target(node_data[order_map[wnode]].first);
-
-      while (node != xnode) {
-        type_map[node] = LOWX;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-      type_map[node] = LOWX;
-
-      node = _graph.target(node_data[order_map[xnode]].first);
-      while (node != root) {
-        type_map[node] = HIGHX;
-        node = _graph.target(node_data[order_map[node]].first);
-      }
-
-      type_map[wnode] = PERTINENT;
-      type_map[root] = ROOT;
-    }
-
-    void findInternalPath(std::vector<Arc>& ipath,
-                          Node wnode, Node root, TypeMap& type_map,
-                          OrderMap& order_map, NodeData& node_data,
-                          ArcLists& arc_lists) {
-      std::vector<Arc> st;
-
-      Node node = wnode;
-
-      while (node != root) {
-        Arc arc = arc_lists[node_data[order_map[node]].first].next;
-        st.push_back(arc);
-        node = _graph.target(arc);
-      }
-
-      while (true) {
-        Arc arc = st.back();
-        if (type_map[_graph.target(arc)] == LOWX ||
-            type_map[_graph.target(arc)] == HIGHX) {
-          break;
-        }
-        if (type_map[_graph.target(arc)] == 2) {
-          type_map[_graph.target(arc)] = 3;
-
-          arc = arc_lists[_graph.oppositeArc(arc)].next;
-          st.push_back(arc);
-        } else {
-          st.pop_back();
-          arc = arc_lists[arc].next;
-
-          while (_graph.oppositeArc(arc) == st.back()) {
-            arc = st.back();
-            st.pop_back();
-            arc = arc_lists[arc].next;
-          }
-          st.push_back(arc);
-        }
-      }
-
-      for (int i = 0; i < int(st.size()); ++i) {
-        if (type_map[_graph.target(st[i])] != LOWY &&
-            type_map[_graph.target(st[i])] != HIGHY) {
-          for (; i < int(st.size()); ++i) {
-            ipath.push_back(st[i]);
-          }
-        }
-      }
-    }
-
-    void setInternalFlags(std::vector<Arc>& ipath, TypeMap& type_map) {
-      for (int i = 1; i < int(ipath.size()); ++i) {
-        type_map[_graph.source(ipath[i])] = INTERNAL;
-      }
-    }
-
-    void findPilePath(std::vector<Arc>& ppath,
-                      Node root, TypeMap& type_map, OrderMap& order_map,
-                      NodeData& node_data, ArcLists& arc_lists) {
-      std::vector<Arc> st;
-
-      st.push_back(_graph.oppositeArc(node_data[order_map[root]].first));
-      st.push_back(node_data[order_map[root]].first);
-
-      while (st.size() > 1) {
-        Arc arc = st.back();
-        if (type_map[_graph.target(arc)] == INTERNAL) {
-          break;
-        }
-        if (type_map[_graph.target(arc)] == 3) {
-          type_map[_graph.target(arc)] = 4;
-
-          arc = arc_lists[_graph.oppositeArc(arc)].next;
-          st.push_back(arc);
-        } else {
-          st.pop_back();
-          arc = arc_lists[arc].next;
-
-          while (!st.empty() && _graph.oppositeArc(arc) == st.back()) {
-            arc = st.back();
-            st.pop_back();
-            arc = arc_lists[arc].next;
-          }
-          st.push_back(arc);
-        }
-      }
-
-      for (int i = 1; i < int(st.size()); ++i) {
-        ppath.push_back(st[i]);
-      }
-    }
-
-
-    int markExternalPath(Node node, OrderMap& order_map,
-                         ChildLists& child_lists, PredMap& pred_map,
-                         AncestorMap& ancestor_map, LowMap& low_map) {
-      int lp = lowPoint(node, order_map, child_lists,
-                        ancestor_map, low_map);
-
-      if (ancestor_map[node] != lp) {
-        node = child_lists[node].first;
-        _kuratowski[pred_map[node]] = true;
-
-        while (ancestor_map[node] != lp) {
-          for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-            Node tnode = _graph.target(e);
-            if (order_map[tnode] > order_map[node] && low_map[tnode] == lp) {
-              node = tnode;
-              _kuratowski[e] = true;
-              break;
-            }
-          }
-        }
-      }
-
-      for (OutArcIt e(_graph, node); e != INVALID; ++e) {
-        if (order_map[_graph.target(e)] == lp) {
-          _kuratowski[e] = true;
-          break;
-        }
-      }
-
-      return lp;
-    }
-
-    void markPertinentPath(Node node, OrderMap& order_map,
-                           NodeData& node_data, ArcLists& arc_lists,
-                           EmbedArc& embed_arc, MergeRoots& merge_roots) {
-      while (embed_arc[node] == INVALID) {
-        int n = merge_roots[node].front();
-        Arc arc = node_data[n].first;
-
-        _kuratowski.set(arc, true);
-
-        Node pred = node;
-        node = _graph.target(arc);
-        while (!pertinent(node, embed_arc, merge_roots)) {
-          arc = node_data[order_map[node]].first;
-          if (_graph.target(arc) == pred) {
-            arc = arc_lists[arc].next;
-          }
-          _kuratowski.set(arc, true);
-          pred = node;
-          node = _graph.target(arc);
-        }
-      }
-      _kuratowski.set(embed_arc[node], true);
-    }
-
-    void markPredPath(Node node, Node snode, PredMap& pred_map) {
-      while (node != snode) {
-        _kuratowski.set(pred_map[node], true);
-        node = _graph.source(pred_map[node]);
-      }
-    }
-
-    void markFacePath(Node ynode, Node xnode,
-                      OrderMap& order_map, NodeData& node_data) {
-      Arc arc = node_data[order_map[ynode]].first;
-      Node node = _graph.target(arc);
-      _kuratowski.set(arc, true);
-
-      while (node != xnode) {
-        arc = node_data[order_map[node]].first;
-        _kuratowski.set(arc, true);
-        node = _graph.target(arc);
-      }
-    }
-
-    void markInternalPath(std::vector<Arc>& path) {
-      for (int i = 0; i < int(path.size()); ++i) {
-        _kuratowski.set(path[i], true);
-      }
-    }
-
-    void markPilePath(std::vector<Arc>& path) {
-      for (int i = 0; i < int(path.size()); ++i) {
-        _kuratowski.set(path[i], true);
-      }
-    }
-
-    void isolateKuratowski(Arc arc, NodeData& node_data,
-                           ArcLists& arc_lists, FlipMap& flip_map,
-                           OrderMap& order_map, OrderList& order_list,
-                           PredMap& pred_map, ChildLists& child_lists,
-                           AncestorMap& ancestor_map, LowMap& low_map,
-                           EmbedArc& embed_arc, MergeRoots& merge_roots) {
-
-      Node root = _graph.source(arc);
-      Node enode = _graph.target(arc);
-
-      int rorder = order_map[root];
-
-      TypeMap type_map(_graph, 0);
-
-      int rn = findComponentRoot(root, enode, child_lists,
-                                 order_map, order_list);
-
-      Node xnode = order_list[node_data[rn].next];
-      Node ynode = order_list[node_data[rn].prev];
-
-      // Minor-A
-      {
-        while (!merge_roots[xnode].empty() || !merge_roots[ynode].empty()) {
-
-          if (!merge_roots[xnode].empty()) {
-            root = xnode;
-            rn = merge_roots[xnode].front();
-          } else {
-            root = ynode;
-            rn = merge_roots[ynode].front();
-          }
-
-          xnode = order_list[node_data[rn].next];
-          ynode = order_list[node_data[rn].prev];
-        }
-
-        if (root != _graph.source(arc)) {
-          orientComponent(root, rn, order_map, pred_map,
-                          node_data, arc_lists, flip_map, type_map);
-          markFacePath(root, root, order_map, node_data);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          Node lwnode = findPertinent(ynode, order_map, node_data,
-                                      embed_arc, merge_roots);
-
-          markPertinentPath(lwnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-
-          return;
-        }
-      }
-
-      orientComponent(root, rn, order_map, pred_map,
-                      node_data, arc_lists, flip_map, type_map);
-
-      Node wnode = findPertinent(ynode, order_map, node_data,
-                                 embed_arc, merge_roots);
-      setFaceFlags(root, wnode, ynode, xnode, order_map, node_data, type_map);
-
-
-      //Minor-B
-      if (!merge_roots[wnode].empty()) {
-        int cn = merge_roots[wnode].back();
-        Node rep = order_list[cn - order_list.size()];
-        if (low_map[rep] < rorder) {
-          markFacePath(root, root, order_map, node_data);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-
-          Node lwnode, lznode;
-          markCommonPath(wnode, rorder, lwnode, lznode, order_list,
-                         order_map, node_data, arc_lists, embed_arc,
-                         merge_roots, child_lists, ancestor_map, low_map);
-
-          markPertinentPath(lwnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-          int zlp = markExternalPath(lznode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-
-          int minlp = xlp < ylp ? xlp : ylp;
-          if (zlp < minlp) minlp = zlp;
-
-          int maxlp = xlp > ylp ? xlp : ylp;
-          if (zlp > maxlp) maxlp = zlp;
-
-          markPredPath(order_list[maxlp], order_list[minlp], pred_map);
-
-          return;
-        }
-      }
-
-      Node pxnode, pynode;
-      std::vector<Arc> ipath;
-      findInternalPath(ipath, wnode, root, type_map, order_map,
-                       node_data, arc_lists);
-      setInternalFlags(ipath, type_map);
-      pynode = _graph.source(ipath.front());
-      pxnode = _graph.target(ipath.back());
-
-      wnode = findPertinent(pynode, order_map, node_data,
-                            embed_arc, merge_roots);
-
-      // Minor-C
-      {
-        if (type_map[_graph.source(ipath.front())] == HIGHY) {
-          if (type_map[_graph.target(ipath.back())] == HIGHX) {
-            markFacePath(xnode, pxnode, order_map, node_data);
-          }
-          markFacePath(root, xnode, order_map, node_data);
-          markPertinentPath(wnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-          markInternalPath(ipath);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          return;
-        }
-
-        if (type_map[_graph.target(ipath.back())] == HIGHX) {
-          markFacePath(ynode, root, order_map, node_data);
-          markPertinentPath(wnode, order_map, node_data, arc_lists,
-                            embed_arc, merge_roots);
-          markInternalPath(ipath);
-          int xlp = markExternalPath(xnode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          int ylp = markExternalPath(ynode, order_map, child_lists,
-                                     pred_map, ancestor_map, low_map);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          return;
-        }
-      }
-
-      std::vector<Arc> ppath;
-      findPilePath(ppath, root, type_map, order_map, node_data, arc_lists);
-
-      // Minor-D
-      if (!ppath.empty()) {
-        markFacePath(ynode, xnode, order_map, node_data);
-        markPertinentPath(wnode, order_map, node_data, arc_lists,
-                          embed_arc, merge_roots);
-        markPilePath(ppath);
-        markInternalPath(ipath);
-        int xlp = markExternalPath(xnode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        int ylp = markExternalPath(ynode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-        return;
-      }
-
-      // Minor-E*
-      {
-
-        if (!external(wnode, rorder, child_lists, ancestor_map, low_map)) {
-          Node znode = findExternal(pynode, rorder, order_map,
-                                    child_lists, ancestor_map,
-                                    low_map, node_data);
-
-          if (type_map[znode] == LOWY) {
-            markFacePath(root, xnode, order_map, node_data);
-            markPertinentPath(wnode, order_map, node_data, arc_lists,
-                              embed_arc, merge_roots);
-            markInternalPath(ipath);
-            int xlp = markExternalPath(xnode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            int zlp = markExternalPath(znode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            markPredPath(root, order_list[xlp < zlp ? xlp : zlp], pred_map);
-          } else {
-            markFacePath(ynode, root, order_map, node_data);
-            markPertinentPath(wnode, order_map, node_data, arc_lists,
-                              embed_arc, merge_roots);
-            markInternalPath(ipath);
-            int ylp = markExternalPath(ynode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            int zlp = markExternalPath(znode, order_map, child_lists,
-                                       pred_map, ancestor_map, low_map);
-            markPredPath(root, order_list[ylp < zlp ? ylp : zlp], pred_map);
-          }
-          return;
-        }
-
-        int xlp = markExternalPath(xnode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        int ylp = markExternalPath(ynode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-        int wlp = markExternalPath(wnode, order_map, child_lists,
-                                   pred_map, ancestor_map, low_map);
-
-        if (wlp > xlp && wlp > ylp) {
-          markFacePath(root, root, order_map, node_data);
-          markPredPath(root, order_list[xlp < ylp ? xlp : ylp], pred_map);
-          return;
-        }
-
-        markInternalPath(ipath);
-        markPertinentPath(wnode, order_map, node_data, arc_lists,
-                          embed_arc, merge_roots);
-
-        if (xlp > ylp && xlp > wlp) {
-          markFacePath(root, pynode, order_map, node_data);
-          markFacePath(wnode, xnode, order_map, node_data);
-          markPredPath(root, order_list[ylp < wlp ? ylp : wlp], pred_map);
-          return;
-        }
-
-        if (ylp > xlp && ylp > wlp) {
-          markFacePath(pxnode, root, order_map, node_data);
-          markFacePath(ynode, wnode, order_map, node_data);
-          markPredPath(root, order_list[xlp < wlp ? xlp : wlp], pred_map);
-          return;
-        }
-
-        if (pynode != ynode) {
-          markFacePath(pxnode, wnode, order_map, node_data);
-
-          int minlp = xlp < ylp ? xlp : ylp;
-          if (wlp < minlp) minlp = wlp;
-
-          int maxlp = xlp > ylp ? xlp : ylp;
-          if (wlp > maxlp) maxlp = wlp;
-
-          markPredPath(order_list[maxlp], order_list[minlp], pred_map);
-          return;
-        }
-
-        if (pxnode != xnode) {
-          markFacePath(wnode, pynode, order_map, node_data);
-
-          int minlp = xlp < ylp ? xlp : ylp;
-          if (wlp < minlp) minlp = wlp;
-
-          int maxlp = xlp > ylp ? xlp : ylp;
-          if (wlp > maxlp) maxlp = wlp;
-
-          markPredPath(order_list[maxlp], order_list[minlp], pred_map);
-          return;
-        }
-
-        markFacePath(root, root, order_map, node_data);
-        int minlp = xlp < ylp ? xlp : ylp;
-        if (wlp < minlp) minlp = wlp;
-        markPredPath(root, order_list[minlp], pred_map);
-        return;
-      }
-
-    }
-
-  };
-
-  namespace _planarity_bits {
-
-    template <typename Graph, typename EmbeddingMap>
-    void makeConnected(Graph& graph, EmbeddingMap& embedding) {
-      DfsVisitor<Graph> null_visitor;
-      DfsVisit<Graph, DfsVisitor<Graph> > dfs(graph, null_visitor);
-      dfs.init();
-
-      typename Graph::Node u = INVALID;
-      for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-        if (!dfs.reached(n)) {
-          dfs.addSource(n);
-          dfs.start();
-          if (u == INVALID) {
-            u = n;
-          } else {
-            typename Graph::Node v = n;
-
-            typename Graph::Arc ue = typename Graph::OutArcIt(graph, u);
-            typename Graph::Arc ve = typename Graph::OutArcIt(graph, v);
-
-            typename Graph::Arc e = graph.direct(graph.addEdge(u, v), true);
-
-            if (ue != INVALID) {
-              embedding[e] = embedding[ue];
-              embedding[ue] = e;
-            } else {
-              embedding[e] = e;
-            }
-
-            if (ve != INVALID) {
-              embedding[graph.oppositeArc(e)] = embedding[ve];
-              embedding[ve] = graph.oppositeArc(e);
-            } else {
-              embedding[graph.oppositeArc(e)] = graph.oppositeArc(e);
-            }
-          }
-        }
-      }
-    }
-
-    template <typename Graph, typename EmbeddingMap>
-    void makeBiNodeConnected(Graph& graph, EmbeddingMap& embedding) {
-      typename Graph::template ArcMap<bool> processed(graph);
-
-      std::vector<typename Graph::Arc> arcs;
-      for (typename Graph::ArcIt e(graph); e != INVALID; ++e) {
-        arcs.push_back(e);
-      }
-
-      IterableBoolMap<Graph, typename Graph::Node> visited(graph, false);
-
-      for (int i = 0; i < int(arcs.size()); ++i) {
-        typename Graph::Arc pp = arcs[i];
-        if (processed[pp]) continue;
-
-        typename Graph::Arc e = embedding[graph.oppositeArc(pp)];
-        processed[e] = true;
-        visited.set(graph.source(e), true);
-
-        typename Graph::Arc p = e, l = e;
-        e = embedding[graph.oppositeArc(e)];
-
-        while (e != l) {
-          processed[e] = true;
-
-          if (visited[graph.source(e)]) {
-
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(graph.source(p),
-                                           graph.target(e)), true);
-            embedding[n] = p;
-            embedding[graph.oppositeArc(pp)] = n;
-
-            embedding[graph.oppositeArc(n)] =
-              embedding[graph.oppositeArc(e)];
-            embedding[graph.oppositeArc(e)] =
-              graph.oppositeArc(n);
-
-            p = n;
-            e = embedding[graph.oppositeArc(n)];
-          } else {
-            visited.set(graph.source(e), true);
-            pp = p;
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-          }
-        }
-        visited.setAll(false);
-      }
-    }
-
-
-    template <typename Graph, typename EmbeddingMap>
-    void makeMaxPlanar(Graph& graph, EmbeddingMap& embedding) {
-
-      typename Graph::template NodeMap<int> degree(graph);
-
-      for (typename Graph::NodeIt n(graph); n != INVALID; ++n) {
-        degree[n] = countIncEdges(graph, n);
-      }
-
-      typename Graph::template ArcMap<bool> processed(graph);
-      IterableBoolMap<Graph, typename Graph::Node> visited(graph, false);
-
-      std::vector<typename Graph::Arc> arcs;
-      for (typename Graph::ArcIt e(graph); e != INVALID; ++e) {
-        arcs.push_back(e);
-      }
-
-      for (int i = 0; i < int(arcs.size()); ++i) {
-        typename Graph::Arc e = arcs[i];
-
-        if (processed[e]) continue;
-        processed[e] = true;
-
-        typename Graph::Arc mine = e;
-        int mind = degree[graph.source(e)];
-
-        int face_size = 1;
-
-        typename Graph::Arc l = e;
-        e = embedding[graph.oppositeArc(e)];
-        while (l != e) {
-          processed[e] = true;
-
-          ++face_size;
-
-          if (degree[graph.source(e)] < mind) {
-            mine = e;
-            mind = degree[graph.source(e)];
-          }
-
-          e = embedding[graph.oppositeArc(e)];
-        }
-
-        if (face_size < 4) {
-          continue;
-        }
-
-        typename Graph::Node s = graph.source(mine);
-        for (typename Graph::OutArcIt e(graph, s); e != INVALID; ++e) {
-          visited.set(graph.target(e), true);
-        }
-
-        typename Graph::Arc oppe = INVALID;
-
-        e = embedding[graph.oppositeArc(mine)];
-        e = embedding[graph.oppositeArc(e)];
-        while (graph.target(e) != s) {
-          if (visited[graph.source(e)]) {
-            oppe = e;
-            break;
-          }
-          e = embedding[graph.oppositeArc(e)];
-        }
-        visited.setAll(false);
-
-        if (oppe == INVALID) {
-
-          e = embedding[graph.oppositeArc(mine)];
-          typename Graph::Arc pn = mine, p = e;
-
-          e = embedding[graph.oppositeArc(e)];
-          while (graph.target(e) != s) {
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(s, graph.source(e)), true);
-
-            embedding[n] = pn;
-            embedding[graph.oppositeArc(n)] = e;
-            embedding[graph.oppositeArc(p)] = graph.oppositeArc(n);
-
-            pn = n;
-
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-          }
-
-          embedding[graph.oppositeArc(e)] = pn;
-
-        } else {
-
-          mine = embedding[graph.oppositeArc(mine)];
-          s = graph.source(mine);
-          oppe = embedding[graph.oppositeArc(oppe)];
-          typename Graph::Node t = graph.source(oppe);
-
-          typename Graph::Arc ce = graph.direct(graph.addEdge(s, t), true);
-          embedding[ce] = mine;
-          embedding[graph.oppositeArc(ce)] = oppe;
-
-          typename Graph::Arc pn = ce, p = oppe;
-          e = embedding[graph.oppositeArc(oppe)];
-          while (graph.target(e) != s) {
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(s, graph.source(e)), true);
-
-            embedding[n] = pn;
-            embedding[graph.oppositeArc(n)] = e;
-            embedding[graph.oppositeArc(p)] = graph.oppositeArc(n);
-
-            pn = n;
-
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-
-          }
-          embedding[graph.oppositeArc(e)] = pn;
-
-          pn = graph.oppositeArc(ce), p = mine;
-          e = embedding[graph.oppositeArc(mine)];
-          while (graph.target(e) != t) {
-            typename Graph::Arc n =
-              graph.direct(graph.addEdge(t, graph.source(e)), true);
-
-            embedding[n] = pn;
-            embedding[graph.oppositeArc(n)] = e;
-            embedding[graph.oppositeArc(p)] = graph.oppositeArc(n);
-
-            pn = n;
-
-            p = e;
-            e = embedding[graph.oppositeArc(e)];
-
-          }
-          embedding[graph.oppositeArc(e)] = pn;
-        }
-      }
-    }
-
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Schnyder's planar drawing algorithm
-  ///
-  /// The planar drawing algorithm calculates positions for the nodes
-  /// in the plane. These coordinates satisfy that if the edges are
-  /// represented with straight lines, then they will not intersect
-  /// each other.
-  ///
-  /// Scnyder's algorithm embeds the graph on an \c (n-2)x(n-2) size grid,
-  /// i.e. each node will be located in the \c [0..n-2]x[0..n-2] square.
-  /// The time complexity of the algorithm is O(n).
-  ///
-  /// \see PlanarEmbedding
-  template <typename Graph>
-  class PlanarDrawing {
-  public:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    /// \brief The point type for storing coordinates
-    typedef dim2::Point<int> Point;
-    /// \brief The map type for storing the coordinates of the nodes
-    typedef typename Graph::template NodeMap<Point> PointMap;
-
-
-    /// \brief Constructor
-    ///
-    /// Constructor
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
-    PlanarDrawing(const Graph& graph)
-      : _graph(graph), _point_map(graph) {}
-
-  private:
-
-    template <typename AuxGraph, typename AuxEmbeddingMap>
-    void drawing(const AuxGraph& graph,
-                 const AuxEmbeddingMap& next,
-                 PointMap& point_map) {
-      TEMPLATE_GRAPH_TYPEDEFS(AuxGraph);
-
-      typename AuxGraph::template ArcMap<Arc> prev(graph);
-
-      for (NodeIt n(graph); n != INVALID; ++n) {
-        Arc e = OutArcIt(graph, n);
-
-        Arc p = e, l = e;
-
-        e = next[e];
-        while (e != l) {
-          prev[e] = p;
-          p = e;
-          e = next[e];
-        }
-        prev[e] = p;
-      }
-
-      Node anode, bnode, cnode;
-
-      {
-        Arc e = ArcIt(graph);
-        anode = graph.source(e);
-        bnode = graph.target(e);
-        cnode = graph.target(next[graph.oppositeArc(e)]);
-      }
-
-      IterableBoolMap<AuxGraph, Node> proper(graph, false);
-      typename AuxGraph::template NodeMap<int> conn(graph, -1);
-
-      conn[anode] = conn[bnode] = -2;
-      {
-        for (OutArcIt e(graph, anode); e != INVALID; ++e) {
-          Node m = graph.target(e);
-          if (conn[m] == -1) {
-            conn[m] = 1;
-          }
-        }
-        conn[cnode] = 2;
-
-        for (OutArcIt e(graph, bnode); e != INVALID; ++e) {
-          Node m = graph.target(e);
-          if (conn[m] == -1) {
-            conn[m] = 1;
-          } else if (conn[m] != -2) {
-            conn[m] += 1;
-            Arc pe = graph.oppositeArc(e);
-            if (conn[graph.target(next[pe])] == -2) {
-              conn[m] -= 1;
-            }
-            if (conn[graph.target(prev[pe])] == -2) {
-              conn[m] -= 1;
-            }
-
-            proper.set(m, conn[m] == 1);
-          }
-        }
-      }
-
-
-      typename AuxGraph::template ArcMap<int> angle(graph, -1);
-
-      while (proper.trueNum() != 0) {
-        Node n = typename IterableBoolMap<AuxGraph, Node>::TrueIt(proper);
-        proper.set(n, false);
-        conn[n] = -2;
-
-        for (OutArcIt e(graph, n); e != INVALID; ++e) {
-          Node m = graph.target(e);
-          if (conn[m] == -1) {
-            conn[m] = 1;
-          } else if (conn[m] != -2) {
-            conn[m] += 1;
-            Arc pe = graph.oppositeArc(e);
-            if (conn[graph.target(next[pe])] == -2) {
-              conn[m] -= 1;
-            }
-            if (conn[graph.target(prev[pe])] == -2) {
-              conn[m] -= 1;
-            }
-
-            proper.set(m, conn[m] == 1);
-          }
-        }
-
-        {
-          Arc e = OutArcIt(graph, n);
-          Arc p = e, l = e;
-
-          e = next[e];
-          while (e != l) {
-
-            if (conn[graph.target(e)] == -2 && conn[graph.target(p)] == -2) {
-              Arc f = e;
-              angle[f] = 0;
-              f = next[graph.oppositeArc(f)];
-              angle[f] = 1;
-              f = next[graph.oppositeArc(f)];
-              angle[f] = 2;
-            }
-
-            p = e;
-            e = next[e];
-          }
-
-          if (conn[graph.target(e)] == -2 && conn[graph.target(p)] == -2) {
-            Arc f = e;
-            angle[f] = 0;
-            f = next[graph.oppositeArc(f)];
-            angle[f] = 1;
-            f = next[graph.oppositeArc(f)];
-            angle[f] = 2;
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<Node> apred(graph, INVALID);
-      typename AuxGraph::template NodeMap<Node> bpred(graph, INVALID);
-      typename AuxGraph::template NodeMap<Node> cpred(graph, INVALID);
-
-      typename AuxGraph::template NodeMap<int> apredid(graph, -1);
-      typename AuxGraph::template NodeMap<int> bpredid(graph, -1);
-      typename AuxGraph::template NodeMap<int> cpredid(graph, -1);
-
-      for (ArcIt e(graph); e != INVALID; ++e) {
-        if (angle[e] == angle[next[e]]) {
-          switch (angle[e]) {
-          case 2:
-            apred[graph.target(e)] = graph.source(e);
-            apredid[graph.target(e)] = graph.id(graph.source(e));
-            break;
-          case 1:
-            bpred[graph.target(e)] = graph.source(e);
-            bpredid[graph.target(e)] = graph.id(graph.source(e));
-            break;
-          case 0:
-            cpred[graph.target(e)] = graph.source(e);
-            cpredid[graph.target(e)] = graph.id(graph.source(e));
-            break;
-          }
-        }
-      }
-
-      cpred[anode] = INVALID;
-      cpred[bnode] = INVALID;
-
-      std::vector<Node> aorder, border, corder;
-
-      {
-        typename AuxGraph::template NodeMap<bool> processed(graph, false);
-        std::vector<Node> st;
-        for (NodeIt n(graph); n != INVALID; ++n) {
-          if (!processed[n] && n != bnode && n != cnode) {
-            st.push_back(n);
-            processed[n] = true;
-            Node m = apred[n];
-            while (m != INVALID && !processed[m]) {
-              st.push_back(m);
-              processed[m] = true;
-              m = apred[m];
-            }
-            while (!st.empty()) {
-              aorder.push_back(st.back());
-              st.pop_back();
-            }
-          }
-        }
-      }
-
-      {
-        typename AuxGraph::template NodeMap<bool> processed(graph, false);
-        std::vector<Node> st;
-        for (NodeIt n(graph); n != INVALID; ++n) {
-          if (!processed[n] && n != cnode && n != anode) {
-            st.push_back(n);
-            processed[n] = true;
-            Node m = bpred[n];
-            while (m != INVALID && !processed[m]) {
-              st.push_back(m);
-              processed[m] = true;
-              m = bpred[m];
-            }
-            while (!st.empty()) {
-              border.push_back(st.back());
-              st.pop_back();
-            }
-          }
-        }
-      }
-
-      {
-        typename AuxGraph::template NodeMap<bool> processed(graph, false);
-        std::vector<Node> st;
-        for (NodeIt n(graph); n != INVALID; ++n) {
-          if (!processed[n] && n != anode && n != bnode) {
-            st.push_back(n);
-            processed[n] = true;
-            Node m = cpred[n];
-            while (m != INVALID && !processed[m]) {
-              st.push_back(m);
-              processed[m] = true;
-              m = cpred[m];
-            }
-            while (!st.empty()) {
-              corder.push_back(st.back());
-              st.pop_back();
-            }
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<int> atree(graph, 0);
-      for (int i = aorder.size() - 1; i >= 0; --i) {
-        Node n = aorder[i];
-        atree[n] = 1;
-        for (OutArcIt e(graph, n); e != INVALID; ++e) {
-          if (apred[graph.target(e)] == n) {
-            atree[n] += atree[graph.target(e)];
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<int> btree(graph, 0);
-      for (int i = border.size() - 1; i >= 0; --i) {
-        Node n = border[i];
-        btree[n] = 1;
-        for (OutArcIt e(graph, n); e != INVALID; ++e) {
-          if (bpred[graph.target(e)] == n) {
-            btree[n] += btree[graph.target(e)];
-          }
-        }
-      }
-
-      typename AuxGraph::template NodeMap<int> apath(graph, 0);
-      apath[bnode] = apath[cnode] = 1;
-      typename AuxGraph::template NodeMap<int> apath_btree(graph, 0);
-      apath_btree[bnode] = btree[bnode];
-      for (int i = 1; i < int(aorder.size()); ++i) {
-        Node n = aorder[i];
-        apath[n] = apath[apred[n]] + 1;
-        apath_btree[n] = btree[n] + apath_btree[apred[n]];
-      }
-
-      typename AuxGraph::template NodeMap<int> bpath_atree(graph, 0);
-      bpath_atree[anode] = atree[anode];
-      for (int i = 1; i < int(border.size()); ++i) {
-        Node n = border[i];
-        bpath_atree[n] = atree[n] + bpath_atree[bpred[n]];
-      }
-
-      typename AuxGraph::template NodeMap<int> cpath(graph, 0);
-      cpath[anode] = cpath[bnode] = 1;
-      typename AuxGraph::template NodeMap<int> cpath_atree(graph, 0);
-      cpath_atree[anode] = atree[anode];
-      typename AuxGraph::template NodeMap<int> cpath_btree(graph, 0);
-      cpath_btree[bnode] = btree[bnode];
-      for (int i = 1; i < int(corder.size()); ++i) {
-        Node n = corder[i];
-        cpath[n] = cpath[cpred[n]] + 1;
-        cpath_atree[n] = atree[n] + cpath_atree[cpred[n]];
-        cpath_btree[n] = btree[n] + cpath_btree[cpred[n]];
-      }
-
-      typename AuxGraph::template NodeMap<int> third(graph);
-      for (NodeIt n(graph); n != INVALID; ++n) {
-        point_map[n].x =
-          bpath_atree[n] + cpath_atree[n] - atree[n] - cpath[n] + 1;
-        point_map[n].y =
-          cpath_btree[n] + apath_btree[n] - btree[n] - apath[n] + 1;
-      }
-
-    }
-
-  public:
-
-    /// \brief Calculate the node positions
-    ///
-    /// This function calculates the node positions on the plane.
-    /// \return \c true if the graph is planar.
-    bool run() {
-      PlanarEmbedding<Graph> pe(_graph);
-      if (!pe.run()) return false;
-
-      run(pe);
-      return true;
-    }
-
-    /// \brief Calculate the node positions according to a
-    /// combinatorical embedding
-    ///
-    /// This function calculates the node positions on the plane.
-    /// The given \c embedding map should contain a valid combinatorical
-    /// embedding, i.e. a valid cyclic order of the arcs.
-    /// It can be computed using PlanarEmbedding.
-    template <typename EmbeddingMap>
-    void run(const EmbeddingMap& embedding) {
-      typedef SmartEdgeSet<Graph> AuxGraph;
-
-      if (3 * countNodes(_graph) - 6 == countEdges(_graph)) {
-        drawing(_graph, embedding, _point_map);
-        return;
-      }
-
-      AuxGraph aux_graph(_graph);
-      typename AuxGraph::template ArcMap<typename AuxGraph::Arc>
-        aux_embedding(aux_graph);
-
-      {
-
-        typename Graph::template EdgeMap<typename AuxGraph::Edge>
-          ref(_graph);
-
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          ref[e] = aux_graph.addEdge(_graph.u(e), _graph.v(e));
-        }
-
-        for (EdgeIt e(_graph); e != INVALID; ++e) {
-          Arc ee = embedding[_graph.direct(e, true)];
-          aux_embedding[aux_graph.direct(ref[e], true)] =
-            aux_graph.direct(ref[ee], _graph.direction(ee));
-          ee = embedding[_graph.direct(e, false)];
-          aux_embedding[aux_graph.direct(ref[e], false)] =
-            aux_graph.direct(ref[ee], _graph.direction(ee));
-        }
-      }
-      _planarity_bits::makeConnected(aux_graph, aux_embedding);
-      _planarity_bits::makeBiNodeConnected(aux_graph, aux_embedding);
-      _planarity_bits::makeMaxPlanar(aux_graph, aux_embedding);
-      drawing(aux_graph, aux_embedding, _point_map);
-    }
-
-    /// \brief The coordinate of the given node
-    ///
-    /// This function returns the coordinate of the given node.
-    Point operator[](const Node& node) const {
-      return _point_map[node];
-    }
-
-    /// \brief Return the grid embedding in a node map
-    ///
-    /// This function returns the grid embedding in a node map of
-    /// \c dim2::Point<int> coordinates.
-    const PointMap& coords() const {
-      return _point_map;
-    }
-
-  private:
-
-    const Graph& _graph;
-    PointMap _point_map;
-
-  };
-
-  namespace _planarity_bits {
-
-    template <typename ColorMap>
-    class KempeFilter {
-    public:
-      typedef typename ColorMap::Key Key;
-      typedef bool Value;
-
-      KempeFilter(const ColorMap& color_map,
-                  const typename ColorMap::Value& first,
-                  const typename ColorMap::Value& second)
-        : _color_map(color_map), _first(first), _second(second) {}
-
-      Value operator[](const Key& key) const {
-        return _color_map[key] == _first || _color_map[key] == _second;
-      }
-
-    private:
-      const ColorMap& _color_map;
-      typename ColorMap::Value _first, _second;
-    };
-  }
-
-  /// \ingroup planar
-  ///
-  /// \brief Coloring planar graphs
-  ///
-  /// The graph coloring problem is the coloring of the graph nodes
-  /// so that there are no adjacent nodes with the same color. The
-  /// planar graphs can always be colored with four colors, which is
-  /// proved by Appel and Haken. Their proofs provide a quadratic
-  /// time algorithm for four coloring, but it could not be used to
-  /// implement an efficient algorithm. The five and six coloring can be
-  /// made in linear time, but in this class, the five coloring has
-  /// quadratic worst case time complexity. The two coloring (if
-  /// possible) is solvable with a graph search algorithm and it is
-  /// implemented in \ref bipartitePartitions() function in LEMON. To
-  /// decide whether a planar graph is three colorable is NP-complete.
-  ///
-  /// This class contains member functions for calculate colorings
-  /// with five and six colors. The six coloring algorithm is a simple
-  /// greedy coloring on the backward minimum outgoing order of nodes.
-  /// This order can be computed by selecting the node with least
-  /// outgoing arcs to unprocessed nodes in each phase. This order
-  /// guarantees that when a node is chosen for coloring it has at
-  /// most five already colored adjacents. The five coloring algorithm
-  /// use the same method, but if the greedy approach fails to color
-  /// with five colors, i.e. the node has five already different
-  /// colored neighbours, it swaps the colors in one of the connected
-  /// two colored sets with the Kempe recoloring method.
-  template <typename Graph>
-  class PlanarColoring {
-  public:
-
-    TEMPLATE_GRAPH_TYPEDEFS(Graph);
-
-    /// \brief The map type for storing color indices
-    typedef typename Graph::template NodeMap<int> IndexMap;
-    /// \brief The map type for storing colors
-    ///
-    /// The map type for storing colors.
-    /// \see Palette, Color
-    typedef ComposeMap<Palette, IndexMap> ColorMap;
-
-    /// \brief Constructor
-    ///
-    /// Constructor.
-    /// \pre The graph must be simple, i.e. it should not
-    /// contain parallel or loop arcs.
-    PlanarColoring(const Graph& graph)
-      : _graph(graph), _color_map(graph), _palette(0) {
-      _palette.add(Color(1,0,0));
-      _palette.add(Color(0,1,0));
-      _palette.add(Color(0,0,1));
-      _palette.add(Color(1,1,0));
-      _palette.add(Color(1,0,1));
-      _palette.add(Color(0,1,1));
-    }
-
-    /// \brief Return the node map of color indices
-    ///
-    /// This function returns the node map of color indices. The values are
-    /// in the range \c [0..4] or \c [0..5] according to the coloring method.
-    IndexMap colorIndexMap() const {
-      return _color_map;
-    }
-
-    /// \brief Return the node map of colors
-    ///
-    /// This function returns the node map of colors. The values are among
-    /// five or six distinct \ref lemon::Color "colors".
-    ColorMap colorMap() const {
-      return composeMap(_palette, _color_map);
-    }
-
-    /// \brief Return the color index of the node
-    ///
-    /// This function returns the color index of the given node. The value is
-    /// in the range \c [0..4] or \c [0..5] according to the coloring method.
-    int colorIndex(const Node& node) const {
-      return _color_map[node];
-    }
-
-    /// \brief Return the color of the node
-    ///
-    /// This function returns the color of the given node. The value is among
-    /// five or six distinct \ref lemon::Color "colors".
-    Color color(const Node& node) const {
-      return _palette[_color_map[node]];
-    }
-
-
-    /// \brief Calculate a coloring with at most six colors
-    ///
-    /// This function calculates a coloring with at most six colors. The time
-    /// complexity of this variant is linear in the size of the graph.
-    /// \return \c true if the algorithm could color the graph with six colors.
-    /// If the algorithm fails, then the graph is not planar.
-    /// \note This function can return \c true if the graph is not
-    /// planar, but it can be colored with at most six colors.
-    bool runSixColoring() {
-
-      typename Graph::template NodeMap<int> heap_index(_graph, -1);
-      BucketHeap<typename Graph::template NodeMap<int> > heap(heap_index);
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _color_map[n] = -2;
-        heap.push(n, countOutArcs(_graph, n));
-      }
-
-      std::vector<Node> order;
-
-      while (!heap.empty()) {
-        Node n = heap.top();
-        heap.pop();
-        _color_map[n] = -1;
-        order.push_back(n);
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] == -2) {
-            heap.decrease(t, heap[t] - 1);
-          }
-        }
-      }
-
-      for (int i = order.size() - 1; i >= 0; --i) {
-        std::vector<bool> forbidden(6, false);
-        for (OutArcIt e(_graph, order[i]); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] != -1) {
-            forbidden[_color_map[t]] = true;
-          }
-        }
-               for (int k = 0; k < 6; ++k) {
-          if (!forbidden[k]) {
-            _color_map[order[i]] = k;
-            break;
-          }
-        }
-        if (_color_map[order[i]] == -1) {
-          return false;
-        }
-      }
-      return true;
-    }
-
-  private:
-
-    bool recolor(const Node& u, const Node& v) {
-      int ucolor = _color_map[u];
-      int vcolor = _color_map[v];
-      typedef _planarity_bits::KempeFilter<IndexMap> KempeFilter;
-      KempeFilter filter(_color_map, ucolor, vcolor);
-
-      typedef FilterNodes<const Graph, const KempeFilter> KempeGraph;
-      KempeGraph kempe_graph(_graph, filter);
-
-      std::vector<Node> comp;
-      Bfs<KempeGraph> bfs(kempe_graph);
-      bfs.init();
-      bfs.addSource(u);
-      while (!bfs.emptyQueue()) {
-        Node n = bfs.nextNode();
-        if (n == v) return false;
-        comp.push_back(n);
-        bfs.processNextNode();
-      }
-
-      int scolor = ucolor + vcolor;
-      for (int i = 0; i < static_cast<int>(comp.size()); ++i) {
-        _color_map[comp[i]] = scolor - _color_map[comp[i]];
-      }
-
-      return true;
-    }
-
-    template <typename EmbeddingMap>
-    void kempeRecoloring(const Node& node, const EmbeddingMap& embedding) {
-      std::vector<Node> nodes;
-      nodes.reserve(4);
-
-      for (Arc e = OutArcIt(_graph, node); e != INVALID; e = embedding[e]) {
-        Node t = _graph.target(e);
-        if (_color_map[t] != -1) {
-          nodes.push_back(t);
-          if (nodes.size() == 4) break;
-        }
-      }
-
-      int color = _color_map[nodes[0]];
-      if (recolor(nodes[0], nodes[2])) {
-        _color_map[node] = color;
-      } else {
-        color = _color_map[nodes[1]];
-        recolor(nodes[1], nodes[3]);
-        _color_map[node] = color;
-      }
-    }
-
-  public:
-
-    /// \brief Calculate a coloring with at most five colors
-    ///
-    /// This function calculates a coloring with at most five
-    /// colors. The worst case time complexity of this variant is
-    /// quadratic in the size of the graph.
-    /// \param embedding This map should contain a valid combinatorical
-    /// embedding, i.e. a valid cyclic order of the arcs.
-    /// It can be computed using PlanarEmbedding.
-    template <typename EmbeddingMap>
-    void runFiveColoring(const EmbeddingMap& embedding) {
-
-      typename Graph::template NodeMap<int> heap_index(_graph, -1);
-      BucketHeap<typename Graph::template NodeMap<int> > heap(heap_index);
-
-      for (NodeIt n(_graph); n != INVALID; ++n) {
-        _color_map[n] = -2;
-        heap.push(n, countOutArcs(_graph, n));
-      }
-
-      std::vector<Node> order;
-
-      while (!heap.empty()) {
-        Node n = heap.top();
-        heap.pop();
-        _color_map[n] = -1;
-        order.push_back(n);
-        for (OutArcIt e(_graph, n); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] == -2) {
-            heap.decrease(t, heap[t] - 1);
-          }
-        }
-      }
-
-      for (int i = order.size() - 1; i >= 0; --i) {
-        std::vector<bool> forbidden(5, false);
-        for (OutArcIt e(_graph, order[i]); e != INVALID; ++e) {
-          Node t = _graph.runningNode(e);
-          if (_color_map[t] != -1) {
-            forbidden[_color_map[t]] = true;
-          }
-        }
-        for (int k = 0; k < 5; ++k) {
-          if (!forbidden[k]) {
-            _color_map[order[i]] = k;
-            break;
-          }
-        }
-        if (_color_map[order[i]] == -1) {
-          kempeRecoloring(order[i], embedding);
-        }
-      }
-    }
-
-    /// \brief Calculate a coloring with at most five colors
-    ///
-    /// This function calculates a coloring with at most five
-    /// colors. The worst case time complexity of this variant is
-    /// quadratic in the size of the graph.
-    /// \return \c true if the graph is planar.
-    bool runFiveColoring() {
-      PlanarEmbedding<Graph> pe(_graph);
-      if (!pe.run()) return false;
-
-      runFiveColoring(pe.embeddingMap());
-      return true;
-    }
-
-  private:
-
-    const Graph& _graph;
-    IndexMap _color_map;
-    Palette _palette;
-  };
-
-}
-
-#endif
Index: lemon/preflow.h
===================================================================
--- lemon/preflow.h	(revision 966)
+++ lemon/preflow.h	(revision 923)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -53,9 +53,5 @@
     /// The type of the map that stores the flow values.
     /// It must meet the \ref concepts::ReadWriteMap "ReadWriteMap" concept.
-#ifdef DOXYGEN
-    typedef GR::ArcMap<Value> FlowMap;
-#else
     typedef typename Digraph::template ArcMap<Value> FlowMap;
-#endif
 
     /// \brief Instantiates a FlowMap.
@@ -72,10 +68,7 @@
     /// The elevator type used by Preflow algorithm.
     ///
-    /// \sa Elevator, LinkedElevator
-#ifdef DOXYGEN
-    typedef lemon::Elevator<GR, GR::Node> Elevator;
-#else
-    typedef lemon::Elevator<Digraph, typename Digraph::Node> Elevator;
-#endif
+    /// \sa Elevator
+    /// \sa LinkedElevator
+    typedef LinkedElevator<Digraph, typename Digraph::Node> Elevator;
 
     /// \brief Instantiates an Elevator.
@@ -103,8 +96,7 @@
   /// This class provides an implementation of Goldberg-Tarjan's \e preflow
   /// \e push-relabel algorithm producing a \ref max_flow
-  /// "flow of maximum value" in a digraph \ref clrs01algorithms,
-  /// \ref amo93networkflows, \ref goldberg88newapproach.
+  /// "flow of maximum value" in a digraph.
   /// The preflow algorithms are the fastest known maximum
-  /// flow algorithms. The current implementation uses a mixture of the
+  /// flow algorithms. The current implementation use a mixture of the
   /// \e "highest label" and the \e "bound decrease" heuristics.
   /// The worst case time complexity of the algorithm is \f$O(n^2\sqrt{e})\f$.
@@ -114,15 +106,7 @@
   /// second phase constructs a feasible maximum flow on each arc.
   ///
-  /// \warning This implementation cannot handle infinite or very large
-  /// capacities (e.g. the maximum value of \c CAP::Value).
-  ///
   /// \tparam GR The type of the digraph the algorithm runs on.
   /// \tparam CAP The type of the capacity map. The default map
   /// type is \ref concepts::Digraph::ArcMap "GR::ArcMap<int>".
-  /// \tparam TR The traits class that defines various types used by the
-  /// algorithm. By default, it is \ref PreflowDefaultTraits
-  /// "PreflowDefaultTraits<GR, CAP>".
-  /// In most cases, this parameter should not be set directly,
-  /// consider to use the named template parameters instead.
 #ifdef DOXYGEN
   template <typename GR, typename CAP, typename TR>
@@ -274,5 +258,5 @@
     /// able to automatically created by the algorithm (i.e. the
     /// digraph and the maximum level should be passed to it).
-    /// However, an external elevator object could also be passed to the
+    /// However an external elevator object could also be passed to the
     /// algorithm with the \ref elevator(Elevator&) "elevator()" function
     /// before calling \ref run() or \ref init().
@@ -388,8 +372,7 @@
     }
 
-    /// \brief Sets the tolerance used by the algorithm.
-    ///
-    /// Sets the tolerance object used by the algorithm.
-    /// \return <tt>(*this)</tt>
+    /// \brief Sets the tolerance used by algorithm.
+    ///
+    /// Sets the tolerance used by algorithm.
     Preflow& tolerance(const Tolerance& tolerance) {
       _tolerance = tolerance;
@@ -399,6 +382,5 @@
     /// \brief Returns a const reference to the tolerance.
     ///
-    /// Returns a const reference to the tolerance object used by
-    /// the algorithm.
+    /// Returns a const reference to the tolerance.
     const Tolerance& tolerance() const {
       return _tolerance;
@@ -408,6 +390,6 @@
     /// The simplest way to execute the preflow algorithm is to use
     /// \ref run() or \ref runMinCut().\n
-    /// If you need better control on the initial solution or the execution,
-    /// you have to call one of the \ref init() functions first, then
+    /// If you need more control on the initial solution or the execution,
+    /// first you have to call one of the \ref init() functions, then
     /// \ref startFirstPhase() and if you need it \ref startSecondPhase().
 
Index: mon/quad_heap.h
===================================================================
--- lemon/quad_heap.h	(revision 855)
+++ 	(revision )
@@ -1,343 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_QUAD_HEAP_H
-#define LEMON_QUAD_HEAP_H
-
-///\ingroup heaps
-///\file
-///\brief Fourary (quaternary) heap implementation.
-
-#include <vector>
-#include <utility>
-#include <functional>
-
-namespace lemon {
-
-  /// \ingroup heaps
-  ///
-  ///\brief Fourary (quaternary) heap data structure.
-  ///
-  /// This class implements the \e Fourary (\e quaternary) \e heap
-  /// data structure.
-  /// It fully conforms to the \ref concepts::Heap "heap concept".
-  ///
-  /// The fourary heap is a specialization of the \ref DHeap "D-ary heap"
-  /// for <tt>D=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 DHeap
-#ifdef DOXYGEN
-  template <typename PR, typename IM, typename CMP>
-#else
-  template <typename PR, typename IM, typename CMP = std::less<PR> >
-#endif
-  class QuadHeap {
-  public:
-    /// Type of the item-int map.
-    typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef PR Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
-    /// Type of the item-priority pairs.
-    typedef std::pair<Item,Prio> Pair;
-    /// Functor type for comparing the priorities.
-    typedef CMP Compare;
-
-    /// \brief Type to represent the states of the items.
-    ///
-    /// Each item has a state associated to it. It can be "in heap",
-    /// "pre-heap" or "post-heap". The latter two are indifferent from the
-    /// heap's point of view, but may be useful to the user.
-    ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
-    enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
-    };
-
-  private:
-    std::vector<Pair> _data;
-    Compare _comp;
-    ItemIntMap &_iim;
-
-  public:
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    explicit QuadHeap(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.
-    QuadHeap(ItemIntMap &map, const Compare &comp)
-      : _iim(map), _comp(comp) {}
-
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    void clear() { _data.clear(); }
-
-  private:
-    static int parent(int i) { return (i-1)/4; }
-    static int firstChild(int i) { return 4*i+1; }
-
-    bool less(const Pair &p1, const Pair &p2) const {
-      return _comp(p1.second, p2.second);
-    }
-
-    void bubbleUp(int hole, Pair p) {
-      int par = parent(hole);
-      while( hole>0 && less(p,_data[par]) ) {
-        move(_data[par],hole);
-        hole = par;
-        par = parent(hole);
-      }
-      move(p, hole);
-    }
-
-    void bubbleDown(int hole, Pair p, int length) {
-      if( length>1 ) {
-        int child = firstChild(hole);
-        while( child+3<length ) {
-          int min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( less(_data[++child], _data[min]) ) min=child;
-          if( !less(_data[min], p) )
-            goto ok;
-          move(_data[min], hole);
-          hole = min;
-          child = firstChild(hole);
-        }
-        if ( child<length ) {
-          int min = child;
-          if( ++child<length && less(_data[child], _data[min]) ) min=child;
-          if( ++child<length && less(_data[child], _data[min]) ) min=child;
-          if( less(_data[min], p) ) {
-            move(_data[min], hole);
-            hole = min;
-          }
-        }
-      }
-    ok:
-      move(p, hole);
-    }
-
-    void move(const Pair &p, int i) {
-      _data[i] = p;
-      _iim.set(p.first, i);
-    }
-
-  public:
-    /// \brief Insert a pair of item and priority into the heap.
-    ///
-    /// This function inserts \c p.first to the heap with priority
-    /// \c p.second.
-    /// \param p The pair to insert.
-    /// \pre \c p.first must not be stored in the heap.
-    void push(const Pair &p) {
-      int n = _data.size();
-      _data.resize(n+1);
-      bubbleUp(n, p);
-    }
-
-    /// \brief Insert an item into the heap with the given priority.
-    ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
-    /// \param i The item to insert.
-    /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
-
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    Item top() const { return _data[0].first; }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
-    Prio prio() const { return _data[0].second; }
-
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
-    /// \pre The heap must be non-empty.
-    void pop() {
-      int n = _data.size()-1;
-      _iim.set(_data[0].first, POST_HEAP);
-      if (n>0) bubbleDown(0, _data[n], n);
-      _data.pop_back();
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
-    void erase(const Item &i) {
-      int h = _iim[i];
-      int n = _data.size()-1;
-      _iim.set(_data[h].first, POST_HEAP);
-      if( h<n ) {
-        if( less(_data[parent(h)], _data[n]) )
-          bubbleDown(h, _data[n], n);
-        else
-          bubbleUp(h, _data[n]);
-      }
-      _data.pop_back();
-    }
-
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
-    Prio operator[](const Item &i) const {
-      int idx = _iim[i];
-      return _data[idx].second;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
-    /// \param i The item.
-    /// \param p The priority.
-    void set(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      if( idx < 0 )
-        push(i,p);
-      else if( _comp(p, _data[idx].second) )
-        bubbleUp(idx, Pair(i,p));
-      else
-        bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    void decrease(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleUp(idx, Pair(i,p));
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
-    /// \param i The item.
-    /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
-    void increase(const Item &i, const Prio &p) {
-      int idx = _iim[i];
-      bubbleDown(idx, Pair(i,p), _data.size());
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
-    /// \param i The item.
-    State state(const Item &i) const {
-      int s = _iim[i];
-      if (s>=0) s=0;
-      return State(s);
-    }
-
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
-    /// \param i The item.
-    /// \param st The state. It should not be \c IN_HEAP.
-    void state(const Item& i, State st) {
-      switch (st) {
-        case POST_HEAP:
-        case PRE_HEAP:
-          if (state(i) == IN_HEAP) erase(i);
-          _iim[i] = st;
-          break;
-        case IN_HEAP:
-          break;
-      }
-    }
-
-    /// \brief Replace an item in the heap.
-    ///
-    /// This function replaces item \c i with item \c j.
-    /// Item \c i must be in the heap, while \c j must be out of the heap.
-    /// After calling this method, item \c i will be out of the
-    /// heap and \c j will be in the heap with the same prioriority
-    /// as item \c i had before.
-    void replace(const Item& i, const Item& j) {
-      int idx = _iim[i];
-      _iim.set(i, _iim[j]);
-      _iim.set(j, idx);
-      _data[idx].first = j;
-    }
-
-  }; // class QuadHeap
-
-} // namespace lemon
-
-#endif // LEMON_FOURARY_HEAP_H
Index: lemon/radix_heap.h
===================================================================
--- lemon/radix_heap.h	(revision 711)
+++ lemon/radix_heap.h	(revision 683)
@@ -20,7 +20,7 @@
 #define LEMON_RADIX_HEAP_H
 
-///\ingroup heaps
+///\ingroup auxdat
 ///\file
-///\brief Radix heap implementation.
+///\brief Radix Heap implementation.
 
 #include <vector>
@@ -30,52 +30,54 @@
 
 
-  /// \ingroup heaps
+  /// \ingroup auxdata
   ///
-  /// \brief Radix heap data structure.
+  /// \brief A Radix Heap implementation.
   ///
-  /// This class implements the \e radix \e heap data structure.
-  /// It practically conforms to the \ref concepts::Heap "heap concept",
-  /// but it has some limitations due its special implementation.
-  /// The type of the priorities must be \c int and the priority of an
-  /// item cannot be decreased under the priority of the last removed item.
+  /// This class implements the \e radix \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. This heap type can store only items with \e int priority.
+  /// In a heap one can change the priority of an item, add or erase an
+  /// item, but the priority cannot be decreased under the last removed
+  /// item's priority.
   ///
-  /// \tparam IM A read-writable item map with \c int values, used
-  /// internally to handle the cross references.
+  /// \param IM A read and writable Item int map, used internally
+  /// to handle the cross references.
+  ///
+  /// \see BinHeap
+  /// \see Dijkstra
   template <typename IM>
   class RadixHeap {
 
   public:
-
-    /// Type of the item-int map.
+    typedef typename IM::Key Item;
+    typedef int Prio;
     typedef IM ItemIntMap;
-    /// Type of the priorities.
-    typedef int Prio;
-    /// Type of the items stored in the heap.
-    typedef typename ItemIntMap::Key Item;
 
     /// \brief Exception thrown by RadixHeap.
     ///
-    /// This exception is thrown when an item is inserted into a
-    /// RadixHeap with a priority smaller than the last erased one.
+    /// This Exception is thrown when a smaller priority
+    /// is inserted into the \e RadixHeap then the last time erased.
     /// \see RadixHeap
-    class PriorityUnderflowError : public Exception {
+
+    class UnderFlowPriorityError : public Exception {
     public:
       virtual const char* what() const throw() {
-        return "lemon::RadixHeap::PriorityUnderflowError";
+        return "lemon::RadixHeap::UnderFlowPriorityError";
       }
     };
 
-    /// \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
+    /// \brief Type to represent the items states.
+    ///
+    /// Each Item element have a state associated to it. It may be "in heap",
+    /// "pre heap" or "post heap". The latter two are indifferent from the
     /// heap's point of view, but may be useful to the user.
     ///
-    /// The item-int map must be initialized in such way that it assigns
-    /// \c PRE_HEAP (<tt>-1</tt>) to any element to be put in the heap.
+    /// The ItemIntMap \e should be initialized in such way that it maps
+    /// PRE_HEAP (-1) to any element to be put in the heap...
     enum State {
-      IN_HEAP = 0,    ///< = 0.
-      PRE_HEAP = -1,  ///< = -1.
-      POST_HEAP = -2  ///< = -2.
+      IN_HEAP = 0,
+      PRE_HEAP = -1,
+      POST_HEAP = -2
     };
 
@@ -95,53 +97,50 @@
     };
 
-    std::vector<RadixItem> _data;
-    std::vector<RadixBox> _boxes;
+    std::vector<RadixItem> data;
+    std::vector<RadixBox> boxes;
 
     ItemIntMap &_iim;
 
+
   public:
-
-    /// \brief Constructor.
-    ///
-    /// Constructor.
-    /// \param map A map that assigns \c int values to the items.
-    /// It is used internally to handle the cross references.
-    /// The assigned value must be \c PRE_HEAP (<tt>-1</tt>) for each item.
-    /// \param minimum The initial minimum value of the heap.
-    /// \param capacity The initial capacity of the heap.
-    RadixHeap(ItemIntMap &map, int minimum = 0, int capacity = 0)
-      : _iim(map)
-    {
-      _boxes.push_back(RadixBox(minimum, 1));
-      _boxes.push_back(RadixBox(minimum + 1, 1));
-      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
+    /// \brief The constructor.
+    ///
+    /// The constructor.
+    ///
+    /// \param map It 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 minimal The initial minimal value of the heap.
+    /// \param capacity It determines the initial capacity of the heap.
+    RadixHeap(ItemIntMap &map, int minimal = 0, int capacity = 0)
+      : _iim(map) {
+      boxes.push_back(RadixBox(minimal, 1));
+      boxes.push_back(RadixBox(minimal + 1, 1));
+      while (lower(boxes.size() - 1, capacity + minimal - 1)) {
         extend();
       }
     }
 
-    /// \brief The number of items stored in the heap.
-    ///
-    /// This function returns the number of items stored in the heap.
-    int size() const { return _data.size(); }
-
-    /// \brief Check if the heap is empty.
-    ///
-    /// This function returns \c true if the heap is empty.
-    bool empty() const { return _data.empty(); }
-
-    /// \brief Make the heap empty.
-    ///
-    /// This functon makes the heap empty.
-    /// It does not change the cross reference map. If you want to reuse
-    /// a heap that is not surely empty, you should first clear it and
-    /// then you should set the cross reference map to \c PRE_HEAP
-    /// for each item.
-    /// \param minimum The minimum value of the heap.
-    /// \param capacity The capacity of the heap.
-    void clear(int minimum = 0, int capacity = 0) {
-      _data.clear(); _boxes.clear();
-      _boxes.push_back(RadixBox(minimum, 1));
-      _boxes.push_back(RadixBox(minimum + 1, 1));
-      while (lower(_boxes.size() - 1, capacity + minimum - 1)) {
+    /// 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 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.
+    void clear(int minimal = 0, int capacity = 0) {
+      data.clear(); boxes.clear();
+      boxes.push_back(RadixBox(minimal, 1));
+      boxes.push_back(RadixBox(minimal + 1, 1));
+      while (lower(boxes.size() - 1, capacity + minimal - 1)) {
         extend();
       }
@@ -151,56 +150,56 @@
 
     bool upper(int box, Prio pr) {
-      return pr < _boxes[box].min;
+      return pr < boxes[box].min;
     }
 
     bool lower(int box, Prio pr) {
-      return pr >= _boxes[box].min + _boxes[box].size;
-    }
-
-    // Remove item from the box list
+      return pr >= boxes[box].min + boxes[box].size;
+    }
+
+    /// \brief Remove item from the box list.
     void remove(int index) {
-      if (_data[index].prev >= 0) {
-        _data[_data[index].prev].next = _data[index].next;
+      if (data[index].prev >= 0) {
+        data[data[index].prev].next = data[index].next;
       } else {
-        _boxes[_data[index].box].first = _data[index].next;
-      }
-      if (_data[index].next >= 0) {
-        _data[_data[index].next].prev = _data[index].prev;
-      }
-    }
-
-    // Insert item into the box list
+        boxes[data[index].box].first = data[index].next;
+      }
+      if (data[index].next >= 0) {
+        data[data[index].next].prev = data[index].prev;
+      }
+    }
+
+    /// \brief Insert item into the box list.
     void insert(int box, int index) {
-      if (_boxes[box].first == -1) {
-        _boxes[box].first = index;
-        _data[index].next = _data[index].prev = -1;
+      if (boxes[box].first == -1) {
+        boxes[box].first = index;
+        data[index].next = data[index].prev = -1;
       } else {
-        _data[index].next = _boxes[box].first;
-        _data[_boxes[box].first].prev = index;
-        _data[index].prev = -1;
-        _boxes[box].first = index;
-      }
-      _data[index].box = box;
-    }
-
-    // Add a new box to the box list
+        data[index].next = boxes[box].first;
+        data[boxes[box].first].prev = index;
+        data[index].prev = -1;
+        boxes[box].first = index;
+      }
+      data[index].box = box;
+    }
+
+    /// \brief Add a new box to the box list.
     void extend() {
-      int min = _boxes.back().min + _boxes.back().size;
-      int bs = 2 * _boxes.back().size;
-      _boxes.push_back(RadixBox(min, bs));
-    }
-
-    // Move an item up into the proper box.
-    void bubbleUp(int index) {
-      if (!lower(_data[index].box, _data[index].prio)) return;
+      int min = boxes.back().min + boxes.back().size;
+      int bs = 2 * boxes.back().size;
+      boxes.push_back(RadixBox(min, bs));
+    }
+
+    /// \brief Move an item up into the proper box.
+    void bubble_up(int index) {
+      if (!lower(data[index].box, data[index].prio)) return;
       remove(index);
-      int box = findUp(_data[index].box, _data[index].prio);
+      int box = findUp(data[index].box, data[index].prio);
       insert(box, index);
     }
 
-    // Find up the proper box for the item with the given priority
+    /// \brief Find up the proper box for the item with the given prio.
     int findUp(int start, int pr) {
       while (lower(start, pr)) {
-        if (++start == int(_boxes.size())) {
+        if (++start == int(boxes.size())) {
           extend();
         }
@@ -209,37 +208,38 @@
     }
 
-    // Move an item down into the proper box
-    void bubbleDown(int index) {
-      if (!upper(_data[index].box, _data[index].prio)) return;
+    /// \brief Move an item down into the proper box.
+    void bubble_down(int index) {
+      if (!upper(data[index].box, data[index].prio)) return;
       remove(index);
-      int box = findDown(_data[index].box, _data[index].prio);
+      int box = findDown(data[index].box, data[index].prio);
       insert(box, index);
     }
 
-    // Find down the proper box for the item with the given priority
+    /// \brief Find up the proper box for the item with the given prio.
     int findDown(int start, int pr) {
       while (upper(start, pr)) {
-        if (--start < 0) throw PriorityUnderflowError();
+        if (--start < 0) throw UnderFlowPriorityError();
       }
       return start;
     }
 
-    // Find the first non-empty box
+    /// \brief Find the first not empty box.
     int findFirst() {
       int first = 0;
-      while (_boxes[first].first == -1) ++first;
+      while (boxes[first].first == -1) ++first;
       return first;
     }
 
-    // Gives back the minimum priority of the given box
+    /// \brief Gives back the minimal prio of the box.
     int minValue(int box) {
-      int min = _data[_boxes[box].first].prio;
-      for (int k = _boxes[box].first; k != -1; k = _data[k].next) {
-        if (_data[k].prio < min) min = _data[k].prio;
+      int min = data[boxes[box].first].prio;
+      for (int k = boxes[box].first; k != -1; k = data[k].next) {
+        if (data[k].prio < min) min = data[k].prio;
       }
       return min;
     }
 
-    // Rearrange the items of the heap and make the first box non-empty
+    /// \brief Rearrange the items of the heap and makes the
+    /// first box not empty.
     void moveDown() {
       int box = findFirst();
@@ -247,29 +247,29 @@
       int min = minValue(box);
       for (int i = 0; i <= box; ++i) {
-        _boxes[i].min = min;
-        min += _boxes[i].size;
-      }
-      int curr = _boxes[box].first, next;
+        boxes[i].min = min;
+        min += boxes[i].size;
+      }
+      int curr = boxes[box].first, next;
       while (curr != -1) {
-        next = _data[curr].next;
-        bubbleDown(curr);
+        next = data[curr].next;
+        bubble_down(curr);
         curr = next;
       }
     }
 
-    void relocateLast(int index) {
-      if (index != int(_data.size()) - 1) {
-        _data[index] = _data.back();
-        if (_data[index].prev != -1) {
-          _data[_data[index].prev].next = index;
+    void relocate_last(int index) {
+      if (index != int(data.size()) - 1) {
+        data[index] = data.back();
+        if (data[index].prev != -1) {
+          data[data[index].prev].next = index;
         } else {
-          _boxes[_data[index].box].first = index;
+          boxes[data[index].box].first = index;
         }
-        if (_data[index].next != -1) {
-          _data[_data[index].next].prev = index;
+        if (data[index].next != -1) {
+          data[data[index].next].prev = index;
         }
-        _iim[_data[index].item] = index;
-      }
-      _data.pop_back();
+        _iim[data[index].item] = index;
+      }
+      data.pop_back();
     }
 
@@ -278,84 +278,78 @@
     /// \brief Insert an item into the heap with the given priority.
     ///
-    /// This function inserts the given item into the heap with the
-    /// given priority.
+    /// Adds \c i to the heap with priority \c p.
     /// \param i The item to insert.
     /// \param p The priority of the item.
-    /// \pre \e i must not be stored in the heap.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void push(const Item &i, const Prio &p) {
-      int n = _data.size();
+      int n = data.size();
       _iim.set(i, n);
-      _data.push_back(RadixItem(i, p));
-      while (lower(_boxes.size() - 1, p)) {
+      data.push_back(RadixItem(i, p));
+      while (lower(boxes.size() - 1, p)) {
         extend();
       }
-      int box = findDown(_boxes.size() - 1, p);
+      int box = findDown(boxes.size() - 1, p);
       insert(box, n);
     }
 
-    /// \brief Return the item having minimum priority.
-    ///
-    /// This function returns the item having minimum priority.
-    /// \pre The heap must be non-empty.
+    /// \brief Returns the item with minimum priority.
+    ///
+    /// This method returns the item with minimum priority.
+    /// \pre The heap must be nonempty.
     Item top() const {
       const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].item;
-    }
-
-    /// \brief The minimum priority.
-    ///
-    /// This function returns the minimum priority.
-    /// \pre The heap must be non-empty.
+      return data[boxes[0].first].item;
+    }
+
+    /// \brief Returns the minimum priority.
+    ///
+    /// It returns the minimum priority.
+    /// \pre The heap must be nonempty.
     Prio prio() const {
       const_cast<RadixHeap<ItemIntMap>&>(*this).moveDown();
-      return _data[_boxes[0].first].prio;
+      return data[boxes[0].first].prio;
      }
 
-    /// \brief Remove the item having minimum priority.
-    ///
-    /// This function removes the item having minimum priority.
+    /// \brief Deletes the item with minimum priority.
+    ///
+    /// This method deletes the item with minimum priority.
     /// \pre The heap must be non-empty.
     void pop() {
       moveDown();
-      int index = _boxes[0].first;
-      _iim[_data[index].item] = POST_HEAP;
+      int index = boxes[0].first;
+      _iim[data[index].item] = POST_HEAP;
       remove(index);
-      relocateLast(index);
-    }
-
-    /// \brief Remove the given item from the heap.
-    ///
-    /// This function removes the given item from the heap if it is
-    /// already stored.
-    /// \param i The item to delete.
-    /// \pre \e i must be in the heap.
+      relocate_last(index);
+    }
+
+    /// \brief Deletes \c i from the heap.
+    ///
+    /// This method deletes item \c i from the heap, if \c i was
+    /// already stored in the heap.
+    /// \param i The item to erase.
     void erase(const Item &i) {
       int index = _iim[i];
       _iim[i] = POST_HEAP;
       remove(index);
-      relocateLast(index);
+      relocate_last(index);
    }
 
-    /// \brief The priority of the given item.
-    ///
-    /// This function returns the priority of the given item.
-    /// \param i The item.
-    /// \pre \e i must be in the heap.
+    /// \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 {
       int idx = _iim[i];
-      return _data[idx].prio;
-    }
-
-    /// \brief Set the priority of an item or insert it, if it is
-    /// not stored in the heap.
-    ///
-    /// This method sets the priority of the given item if it is
-    /// already stored in the heap. Otherwise it inserts the given
-    /// item into the heap with the given priority.
+      return data[idx].prio;
+    }
+
+    /// \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.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be in the heap.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void set(const Item &i, const Prio &p) {
       int idx = _iim[i];
@@ -363,45 +357,46 @@
         push(i, p);
       }
-      else if( p >= _data[idx].prio ) {
-        _data[idx].prio = p;
-        bubbleUp(idx);
+      else if( p >= data[idx].prio ) {
+        data[idx].prio = p;
+        bubble_up(idx);
       } else {
-        _data[idx].prio = p;
-        bubbleDown(idx);
-      }
-    }
-
-    /// \brief Decrease the priority of an item to the given value.
-    ///
-    /// This function decreases the priority of an item to the given value.
+        data[idx].prio = p;
+        bubble_down(idx);
+      }
+    }
+
+
+    /// \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, and
+    /// \c should be greater or equal to the last removed item's priority.
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at least \e p.
-    /// \warning This method may throw an \c UnderFlowPriorityException.
     void decrease(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      _data[idx].prio = p;
-      bubbleDown(idx);
-    }
-
-    /// \brief Increase the priority of an item to the given value.
-    ///
-    /// This function increases the priority of an item to the given value.
+      data[idx].prio = p;
+      bubble_down(idx);
+    }
+
+    /// \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
     /// \param i The item.
     /// \param p The priority.
-    /// \pre \e i must be stored in the heap with priority at most \e p.
     void increase(const Item &i, const Prio &p) {
       int idx = _iim[i];
-      _data[idx].prio = p;
-      bubbleUp(idx);
-    }
-
-    /// \brief Return the state of an item.
-    ///
-    /// This method returns \c PRE_HEAP if the given item has never
-    /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
-    /// and \c POST_HEAP otherwise.
-    /// In the latter case it is possible that the item will get back
-    /// to the heap again.
+      data[idx].prio = p;
+      bubble_up(idx);
+    }
+
+    /// \brief Returns if \c item is in, has already been in, or has
+    /// never been in the heap.
+    ///
+    /// This method returns PRE_HEAP if \c item has never been in the
+    /// heap, IN_HEAP if it is in the heap at the moment, and POST_HEAP
+    /// otherwise. In the latter case it is possible that \c item will
+    /// get back to the heap again.
     /// \param i The item.
     State state(const Item &i) const {
@@ -411,9 +406,9 @@
     }
 
-    /// \brief Set the state of an item in the heap.
-    ///
-    /// This function sets the state of the given item in the heap.
-    /// It can be used to manually clear the heap when it is important
-    /// to achive better time complexity.
+    /// \brief Sets the state of the \c item in the heap.
+    ///
+    /// Sets the state of the \c item in the heap. It can be used to
+    /// manually clear the heap when it is important to achive the
+    /// better time complexity.
     /// \param i The item.
     /// \param st The state. It should not be \c IN_HEAP.
Index: lemon/smart_graph.h
===================================================================
--- lemon/smart_graph.h	(revision 877)
+++ lemon/smart_graph.h	(revision 617)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -33,5 +33,8 @@
 
   class SmartDigraph;
-
+  ///Base of SmartDigraph
+
+  ///Base of SmartDigraph
+  ///
   class SmartDigraphBase {
   protected:
@@ -185,26 +188,26 @@
   ///\brief A smart directed graph class.
   ///
-  ///\ref SmartDigraph is a simple and fast digraph implementation.
-  ///It is also quite memory efficient but at the price
-  ///that it does not support node and arc deletion
-  ///(except for the Snapshot feature).
+  ///This is a simple and fast digraph implementation.
+  ///It is also quite memory efficient, but at the price
+  ///that <b> it does support only limited (only stack-like)
+  ///node and arc deletions</b>.
+  ///It fully conforms to the \ref concepts::Digraph "Digraph concept".
   ///
-  ///This type fully conforms to the \ref concepts::Digraph "Digraph concept"
-  ///and it also provides some additional functionalities.
-  ///Most of its member functions and nested classes are documented
-  ///only in the concept class.
-  ///
-  ///This class provides constant time counting for nodes and arcs.
-  ///
-  ///\sa concepts::Digraph
-  ///\sa SmartGraph
+  ///\sa concepts::Digraph.
   class SmartDigraph : public ExtendedSmartDigraphBase {
     typedef ExtendedSmartDigraphBase Parent;
 
   private:
-    /// Digraphs are \e not copy constructible. Use DigraphCopy instead.
+
+    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+
+    ///SmartDigraph is \e not copy constructible. Use DigraphCopy() instead.
+    ///
     SmartDigraph(const SmartDigraph &) : ExtendedSmartDigraphBase() {};
-    /// \brief Assignment of a digraph to another one is \e not allowed.
-    /// Use DigraphCopy instead.
+    ///\brief Assignment of SmartDigraph to another one is \e not allowed.
+    ///Use DigraphCopy() instead.
+
+    ///Assignment of SmartDigraph to another one is \e not allowed.
+    ///Use DigraphCopy() instead.
     void operator=(const SmartDigraph &) {}
 
@@ -219,47 +222,77 @@
     ///Add a new node to the digraph.
 
-    ///This function adds a new node to the digraph.
-    ///\return The new node.
+    /// Add a new node to the digraph.
+    /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 
     ///Add a new arc to the digraph.
 
-    ///This function adds a new arc to the digraph with source node \c s
+    ///Add a new arc to the digraph with source node \c s
     ///and target node \c t.
     ///\return The new arc.
-    Arc addArc(Node s, Node t) {
+    Arc addArc(const Node& s, const Node& t) {
       return Parent::addArc(s, t);
     }
 
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
+
+    /// Using this it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveArc
+    void reserveNode(int n) { nodes.reserve(n); };
+
+    /// \brief Using this it is possible to avoid the superfluous memory
+    /// allocation.
+
+    /// Using this it is possible to avoid the superfluous memory
+    /// allocation: if you know that the digraph you want to build will
+    /// be very large (e.g. it will contain millions of nodes and/or arcs)
+    /// then it is worth reserving space for this amount before starting
+    /// to build the digraph.
+    /// \sa reserveNode
+    void reserveArc(int m) { arcs.reserve(m); };
+
     /// \brief Node validity check
     ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the digraph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
     ///
     /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the digraph.
+    /// when new nodes are added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
     /// \brief Arc validity check
     ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the digraph.
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
     ///
     /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new arcs are added to the graph.
+    /// when new arcs are added to the graph.
     bool valid(Arc a) const { return Parent::valid(a); }
 
+    ///Clear the digraph.
+
+    ///Erase all the nodes and arcs from the digraph.
+    ///
+    void clear() {
+      Parent::clear();
+    }
+
     ///Split a node.
 
-    ///This function splits the given node. First, a new node is added
-    ///to the digraph, then the source of each outgoing arc of node \c n
-    ///is moved to this new node.
-    ///If the second parameter \c connect is \c true (this is the default
-    ///value), then a new arc from node \c n to the newly created node
-    ///is also added.
+    ///This function splits a node. First a new node is added to the digraph,
+    ///then the source of each outgoing arc of \c n is moved to this new node.
+    ///If \c connect is \c true (this is the default value), then a new arc
+    ///from \c n to the newly created node is also added.
     ///\return The newly created node.
     ///
-    ///\note All iterators remain valid.
-    ///
+    ///\note The <tt>Arc</tt>s
+    ///referencing a moved arc remain
+    ///valid. However <tt>InArc</tt>'s and <tt>OutArc</tt>'s
+    ///may be invalidated.
     ///\warning This functionality cannot be used together with the Snapshot
     ///feature.
@@ -276,32 +309,4 @@
     }
 
-    ///Clear the digraph.
-
-    ///This function erases all nodes and arcs from the digraph.
-    ///
-    void clear() {
-      Parent::clear();
-    }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveArc()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for arcs.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the digraph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or arcs),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the digraph.
-    /// \sa reserveNode()
-    void reserveArc(int m) { arcs.reserve(m); };
-
   public:
 
@@ -328,21 +333,18 @@
   public:
 
-    ///Class to make a snapshot of the digraph and to restore it later.
-
-    ///Class to make a snapshot of the digraph and to restore it later.
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+
+    ///Class to make a snapshot of the digraph and to restrore to it later.
     ///
     ///The newly added nodes and arcs can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///arcs from a SmartDigraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state,
-    ///i.e. you cannot add the removed nodes and arcs again using
-    ///another Snapshot instance.
-    ///
-    ///\warning Node splitting cannot be restored.
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the digraph or no change.
+    ///restore() function.
+    ///\note After you restore a state, you cannot restore
+    ///a later state, in other word you cannot add again the arcs deleted
+    ///by restore() using another one Snapshot instance.
+    ///
+    ///\warning If you do not use correctly the snapshot that can cause
+    ///either broken program, invalid state of the digraph, valid but
+    ///not the restored digraph or no change. Because the runtime performance
+    ///the validity of the snapshot is not stored.
     class Snapshot
     {
@@ -356,11 +358,12 @@
 
       ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
+      ///To actually make a snapshot you must call save().
+      ///
       Snapshot() : _graph(0) {}
       ///Constructor that immediately makes a snapshot
 
-      ///This constructor immediately makes a snapshot of the given digraph.
-      ///
-      Snapshot(SmartDigraph &gr) : _graph(&gr) {
+      ///This constructor immediately makes a snapshot of the digraph.
+      ///\param graph The digraph we make a snapshot of.
+      Snapshot(SmartDigraph &graph) : _graph(&graph) {
         node_num=_graph->nodes.size();
         arc_num=_graph->arcs.size();
@@ -369,9 +372,12 @@
       ///Make a snapshot.
 
-      ///This function makes a snapshot of the given digraph.
-      ///It can be called more than once. In case of a repeated
+      ///Make a snapshot of the digraph.
+      ///
+      ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
-      void save(SmartDigraph &gr) {
-        _graph=&gr;
+      ///\param graph The digraph we make the snapshot of.
+      void save(SmartDigraph &graph)
+      {
+        _graph=&graph;
         node_num=_graph->nodes.size();
         arc_num=_graph->arcs.size();
@@ -380,6 +386,9 @@
       ///Undo the changes until a snapshot.
 
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartDigraph&).
+      ///Undo the changes until a snapshot created by save().
+      ///
+      ///\note After you restored a state, you cannot restore
+      ///a later state, in other word you cannot add again the arcs deleted
+      ///by restore().
       void restore()
       {
@@ -500,5 +509,5 @@
     }
 
-    static void next(Node& node) {
+    void next(Node& node) const {
       --node._id;
     }
@@ -508,5 +517,5 @@
     }
 
-    static void next(Arc& arc) {
+    void next(Arc& arc) const {
       --arc._id;
     }
@@ -516,5 +525,5 @@
     }
 
-    static void next(Edge& arc) {
+    void next(Edge& arc) const {
       --arc._id;
     }
@@ -613,26 +622,27 @@
   /// \brief A smart undirected graph class.
   ///
-  /// \ref SmartGraph is a simple and fast graph implementation.
-  /// It is also quite memory efficient but at the price
-  /// that it does not support node and edge deletion
-  /// (except for the Snapshot feature).
+  /// This is a simple and fast graph implementation.
+  /// It is also quite memory efficient, but at the price
+  /// that <b> it does support only limited (only stack-like)
+  /// node and arc deletions</b>.
+  /// It fully conforms to the \ref concepts::Graph "Graph concept".
   ///
-  /// This type fully conforms to the \ref concepts::Graph "Graph concept"
-  /// and it also provides some additional functionalities.
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes, edges and arcs.
-  ///
-  /// \sa concepts::Graph
-  /// \sa SmartDigraph
+  /// \sa concepts::Graph.
   class SmartGraph : public ExtendedSmartGraphBase {
     typedef ExtendedSmartGraphBase Parent;
 
   private:
-    /// Graphs are \e not copy constructible. Use GraphCopy instead.
+
+    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
+
+    ///SmartGraph is \e not copy constructible. Use GraphCopy() instead.
+    ///
     SmartGraph(const SmartGraph &) : ExtendedSmartGraphBase() {};
-    /// \brief Assignment of a graph to another one is \e not allowed.
-    /// Use GraphCopy instead.
+
+    ///\brief Assignment of SmartGraph to another one is \e not allowed.
+    ///Use GraphCopy() instead.
+
+    ///Assignment of SmartGraph to another one is \e not allowed.
+    ///Use GraphCopy() instead.
     void operator=(const SmartGraph &) {}
 
@@ -645,74 +655,53 @@
     SmartGraph() {}
 
-    /// \brief Add a new node to the graph.
-    ///
-    /// This function adds a new node to the graph.
+    ///Add a new node to the graph.
+
+    /// Add a new node to the graph.
     /// \return The new node.
     Node addNode() { return Parent::addNode(); }
 
-    /// \brief Add a new edge to the graph.
-    ///
-    /// This function adds a new edge to the graph between nodes
-    /// \c u and \c v with inherent orientation from node \c u to
-    /// node \c v.
-    /// \return The new edge.
-    Edge addEdge(Node u, Node v) {
-      return Parent::addEdge(u, v);
+    ///Add a new edge to the graph.
+
+    ///Add a new edge to the graph with node \c s
+    ///and \c t.
+    ///\return The new edge.
+    Edge addEdge(const Node& s, const Node& t) {
+      return Parent::addEdge(s, t);
     }
 
     /// \brief Node validity check
     ///
-    /// This function gives back \c true if the given node is valid,
-    /// i.e. it is a real node of the graph.
+    /// This function gives back true if the given node is valid,
+    /// ie. it is a real node of the graph.
     ///
     /// \warning A removed node (using Snapshot) could become valid again
-    /// if new nodes are added to the graph.
+    /// when new nodes are added to the graph.
     bool valid(Node n) const { return Parent::valid(n); }
 
+    /// \brief Arc validity check
+    ///
+    /// This function gives back true if the given arc is valid,
+    /// ie. it is a real arc of the graph.
+    ///
+    /// \warning A removed arc (using Snapshot) could become valid again
+    /// when new edges are added to the graph.
+    bool valid(Arc a) const { return Parent::valid(a); }
+
     /// \brief Edge validity check
     ///
-    /// This function gives back \c true if the given edge is valid,
-    /// i.e. it is a real edge of the graph.
+    /// This function gives back true if the given edge is valid,
+    /// ie. it is a real edge of the graph.
     ///
     /// \warning A removed edge (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
+    /// when new edges are added to the graph.
     bool valid(Edge e) const { return Parent::valid(e); }
 
-    /// \brief Arc validity check
-    ///
-    /// This function gives back \c true if the given arc is valid,
-    /// i.e. it is a real arc of the graph.
-    ///
-    /// \warning A removed arc (using Snapshot) could become valid again
-    /// if new edges are added to the graph.
-    bool valid(Arc a) const { return Parent::valid(a); }
-
     ///Clear the graph.
 
-    ///This function erases all nodes and arcs from the graph.
+    ///Erase all the nodes and edges from the graph.
     ///
     void clear() {
       Parent::clear();
     }
-
-    /// Reserve memory for nodes.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveEdge()
-    void reserveNode(int n) { nodes.reserve(n); };
-
-    /// Reserve memory for edges.
-
-    /// Using this function, it is possible to avoid superfluous memory
-    /// allocation: if you know that the graph you want to build will
-    /// be large (e.g. it will contain millions of nodes and/or edges),
-    /// then it is worth reserving space for this amount before starting
-    /// to build the graph.
-    /// \sa reserveNode()
-    void reserveEdge(int m) { arcs.reserve(2 * m); };
 
   public:
@@ -754,20 +743,19 @@
   public:
 
-    ///Class to make a snapshot of the graph and to restore it later.
-
-    ///Class to make a snapshot of the graph and to restore it later.
-    ///
-    ///The newly added nodes and edges can be removed using the
-    ///restore() function. This is the only way for deleting nodes and/or
-    ///edges from a SmartGraph structure.
-    ///
-    ///\note After a state is restored, you cannot restore a later state,
-    ///i.e. you cannot add the removed nodes and edges again using
-    ///another Snapshot instance.
-    ///
-    ///\warning The validity of the snapshot is not stored due to
-    ///performance reasons. If you do not use the snapshot correctly,
-    ///it can cause broken program, invalid or not restored state of
-    ///the graph or no change.
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+
+    ///Class to make a snapshot of the digraph and to restrore to it later.
+    ///
+    ///The newly added nodes and arcs can be removed using the
+    ///restore() function.
+    ///
+    ///\note After you restore a state, you cannot restore
+    ///a later state, in other word you cannot add again the arcs deleted
+    ///by restore() using another one Snapshot instance.
+    ///
+    ///\warning If you do not use correctly the snapshot that can cause
+    ///either broken program, invalid state of the digraph, valid but
+    ///not the restored digraph or no change. Because the runtime performance
+    ///the validity of the snapshot is not stored.
     class Snapshot
     {
@@ -781,28 +769,34 @@
 
       ///Default constructor.
-      ///You have to call save() to actually make a snapshot.
+      ///To actually make a snapshot you must call save().
+      ///
       Snapshot() : _graph(0) {}
       ///Constructor that immediately makes a snapshot
 
-      /// This constructor immediately makes a snapshot of the given graph.
+      ///This constructor immediately makes a snapshot of the digraph.
+      ///\param graph The digraph we make a snapshot of.
+      Snapshot(SmartGraph &graph) {
+        graph.saveSnapshot(*this);
+      }
+
+      ///Make a snapshot.
+
+      ///Make a snapshot of the graph.
       ///
-      Snapshot(SmartGraph &gr) {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Make a snapshot.
-
-      ///This function makes a snapshot of the given graph.
-      ///It can be called more than once. In case of a repeated
+      ///This function can be called more than once. In case of a repeated
       ///call, the previous snapshot gets lost.
-      void save(SmartGraph &gr)
+      ///\param graph The digraph we make the snapshot of.
+      void save(SmartGraph &graph)
       {
-        gr.saveSnapshot(*this);
-      }
-
-      ///Undo the changes until the last snapshot.
-
-      ///This function undos the changes until the last snapshot
-      ///created by save() or Snapshot(SmartGraph&).
+        graph.saveSnapshot(*this);
+      }
+
+      ///Undo the changes until a snapshot.
+
+      ///Undo the changes until a snapshot created by save().
+      ///
+      ///\note After you restored a state, you cannot restore
+      ///a later state, in other word you cannot add again the arcs deleted
+      ///by restore().
       void restore()
       {
Index: lemon/soplex.cc
===================================================================
--- lemon/soplex.cc	(revision 877)
+++ lemon/soplex.cc	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -92,17 +92,4 @@
   }
 
-  int SoplexLp::_addRow(Value l, ExprIterator b, ExprIterator e, Value u) {
-    soplex::DSVector v;
-    for (ExprIterator it = b; it != e; ++it) {
-      v.add(it->first, it->second);
-    }
-    soplex::LPRow r(l, v, u);
-    soplex->addRow(r);
-
-    _row_names.push_back(std::string());
-
-    return soplex->nRows() - 1;
-  }
-
 
   void SoplexLp::_eraseCol(int i) {
@@ -288,5 +275,5 @@
 
     _clear_temporals();
-
+    
     _applyMessageLevel();
 
Index: lemon/soplex.h
===================================================================
--- lemon/soplex.h	(revision 877)
+++ lemon/soplex.h	(revision 576)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -85,5 +85,4 @@
     virtual int _addCol();
     virtual int _addRow();
-    virtual int _addRow(Value l, ExprIterator b, ExprIterator e, Value u);
 
     virtual void _eraseCol(int i);
Index: mon/static_graph.h
===================================================================
--- lemon/static_graph.h	(revision 877)
+++ 	(revision )
@@ -1,476 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#ifndef LEMON_STATIC_GRAPH_H
-#define LEMON_STATIC_GRAPH_H
-
-///\ingroup graphs
-///\file
-///\brief StaticDigraph class.
-
-#include <lemon/core.h>
-#include <lemon/bits/graph_extender.h>
-
-namespace lemon {
-
-  class StaticDigraphBase {
-  public:
-
-    StaticDigraphBase()
-      : built(false), node_num(0), arc_num(0),
-        node_first_out(NULL), node_first_in(NULL),
-        arc_source(NULL), arc_target(NULL),
-        arc_next_in(NULL), arc_next_out(NULL) {}
-
-    ~StaticDigraphBase() {
-      if (built) {
-        delete[] node_first_out;
-        delete[] node_first_in;
-        delete[] arc_source;
-        delete[] arc_target;
-        delete[] arc_next_out;
-        delete[] arc_next_in;
-      }
-    }
-
-    class Node {
-      friend class StaticDigraphBase;
-    protected:
-      int id;
-      Node(int _id) : id(_id) {}
-    public:
-      Node() {}
-      Node (Invalid) : id(-1) {}
-      bool operator==(const Node& node) const { return id == node.id; }
-      bool operator!=(const Node& node) const { return id != node.id; }
-      bool operator<(const Node& node) const { return id < node.id; }
-    };
-
-    class Arc {
-      friend class StaticDigraphBase;
-    protected:
-      int id;
-      Arc(int _id) : id(_id) {}
-    public:
-      Arc() { }
-      Arc (Invalid) : id(-1) {}
-      bool operator==(const Arc& arc) const { return id == arc.id; }
-      bool operator!=(const Arc& arc) const { return id != arc.id; }
-      bool operator<(const Arc& arc) const { return id < arc.id; }
-    };
-
-    Node source(const Arc& e) const { return Node(arc_source[e.id]); }
-    Node target(const Arc& e) const { return Node(arc_target[e.id]); }
-
-    void first(Node& n) const { n.id = node_num - 1; }
-    static void next(Node& n) { --n.id; }
-
-    void first(Arc& e) const { e.id = arc_num - 1; }
-    static void next(Arc& e) { --e.id; }
-
-    void firstOut(Arc& e, const Node& n) const {
-      e.id = node_first_out[n.id] != node_first_out[n.id + 1] ?
-        node_first_out[n.id] : -1;
-    }
-    void nextOut(Arc& e) const { e.id = arc_next_out[e.id]; }
-
-    void firstIn(Arc& e, const Node& n) const { e.id = node_first_in[n.id]; }
-    void nextIn(Arc& e) const { e.id = arc_next_in[e.id]; }
-
-    static int id(const Node& n) { return n.id; }
-    static Node nodeFromId(int id) { return Node(id); }
-    int maxNodeId() const { return node_num - 1; }
-
-    static int id(const Arc& e) { return e.id; }
-    static Arc arcFromId(int id) { return Arc(id); }
-    int maxArcId() const { return arc_num - 1; }
-
-    typedef True NodeNumTag;
-    typedef True ArcNumTag;
-
-    int nodeNum() const { return node_num; }
-    int arcNum() const { return arc_num; }
-
-  private:
-
-    template <typename Digraph, typename NodeRefMap>
-    class ArcLess {
-    public:
-      typedef typename Digraph::Arc Arc;
-
-      ArcLess(const Digraph &_graph, const NodeRefMap& _nodeRef)
-        : digraph(_graph), nodeRef(_nodeRef) {}
-
-      bool operator()(const Arc& left, const Arc& right) const {
-        return nodeRef[digraph.target(left)] < nodeRef[digraph.target(right)];
-      }
-    private:
-      const Digraph& digraph;
-      const NodeRefMap& nodeRef;
-    };
-
-  public:
-
-    typedef True BuildTag;
-
-    void clear() {
-      if (built) {
-        delete[] node_first_out;
-        delete[] node_first_in;
-        delete[] arc_source;
-        delete[] arc_target;
-        delete[] arc_next_out;
-        delete[] arc_next_in;
-      }
-      built = false;
-      node_num = 0;
-      arc_num = 0;
-    }
-
-    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
-    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
-      typedef typename Digraph::Node GNode;
-      typedef typename Digraph::Arc GArc;
-
-      built = true;
-
-      node_num = countNodes(digraph);
-      arc_num = countArcs(digraph);
-
-      node_first_out = new int[node_num + 1];
-      node_first_in = new int[node_num];
-
-      arc_source = new int[arc_num];
-      arc_target = new int[arc_num];
-      arc_next_out = new int[arc_num];
-      arc_next_in = new int[arc_num];
-
-      int node_index = 0;
-      for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
-        nodeRef[n] = Node(node_index);
-        node_first_in[node_index] = -1;
-        ++node_index;
-      }
-
-      ArcLess<Digraph, NodeRefMap> arcLess(digraph, nodeRef);
-
-      int arc_index = 0;
-      for (typename Digraph::NodeIt n(digraph); n != INVALID; ++n) {
-        int source = nodeRef[n].id;
-        std::vector<GArc> arcs;
-        for (typename Digraph::OutArcIt e(digraph, n); e != INVALID; ++e) {
-          arcs.push_back(e);
-        }
-        if (!arcs.empty()) {
-          node_first_out[source] = arc_index;
-          std::sort(arcs.begin(), arcs.end(), arcLess);
-          for (typename std::vector<GArc>::iterator it = arcs.begin();
-               it != arcs.end(); ++it) {
-            int target = nodeRef[digraph.target(*it)].id;
-            arcRef[*it] = Arc(arc_index);
-            arc_source[arc_index] = source;
-            arc_target[arc_index] = target;
-            arc_next_in[arc_index] = node_first_in[target];
-            node_first_in[target] = arc_index;
-            arc_next_out[arc_index] = arc_index + 1;
-            ++arc_index;
-          }
-          arc_next_out[arc_index - 1] = -1;
-        } else {
-          node_first_out[source] = arc_index;
-        }
-      }
-      node_first_out[node_num] = arc_num;
-    }
-
-    template <typename ArcListIterator>
-    void build(int n, ArcListIterator first, ArcListIterator last) {
-      built = true;
-
-      node_num = n;
-      arc_num = std::distance(first, last);
-
-      node_first_out = new int[node_num + 1];
-      node_first_in = new int[node_num];
-
-      arc_source = new int[arc_num];
-      arc_target = new int[arc_num];
-      arc_next_out = new int[arc_num];
-      arc_next_in = new int[arc_num];
-
-      for (int i = 0; i != node_num; ++i) {
-        node_first_in[i] = -1;
-      }
-
-      int arc_index = 0;
-      for (int i = 0; i != node_num; ++i) {
-        node_first_out[i] = arc_index;
-        for ( ; first != last && (*first).first == i; ++first) {
-          int j = (*first).second;
-          LEMON_ASSERT(j >= 0 && j < node_num,
-            "Wrong arc list for StaticDigraph::build()");
-          arc_source[arc_index] = i;
-          arc_target[arc_index] = j;
-          arc_next_in[arc_index] = node_first_in[j];
-          node_first_in[j] = arc_index;
-          arc_next_out[arc_index] = arc_index + 1;
-          ++arc_index;
-        }
-        if (arc_index > node_first_out[i])
-          arc_next_out[arc_index - 1] = -1;
-      }
-      LEMON_ASSERT(first == last,
-        "Wrong arc list for StaticDigraph::build()");
-      node_first_out[node_num] = arc_num;
-    }
-
-  protected:
-
-    void fastFirstOut(Arc& e, const Node& n) const {
-      e.id = node_first_out[n.id];
-    }
-
-    static void fastNextOut(Arc& e) {
-      ++e.id;
-    }
-    void fastLastOut(Arc& e, const Node& n) const {
-      e.id = node_first_out[n.id + 1];
-    }
-
-  protected:
-    bool built;
-    int node_num;
-    int arc_num;
-    int *node_first_out;
-    int *node_first_in;
-    int *arc_source;
-    int *arc_target;
-    int *arc_next_in;
-    int *arc_next_out;
-  };
-
-  typedef DigraphExtender<StaticDigraphBase> ExtendedStaticDigraphBase;
-
-
-  /// \ingroup graphs
-  ///
-  /// \brief A static directed graph class.
-  ///
-  /// \ref StaticDigraph is a highly efficient digraph implementation,
-  /// but it is fully static.
-  /// It stores only two \c int values for each node and only four \c int
-  /// values for each arc. Moreover it provides faster item iteration than
-  /// \ref ListDigraph and \ref SmartDigraph, especially using \c OutArcIt
-  /// iterators, since its arcs are stored in an appropriate order.
-  /// However it only provides build() and clear() functions and does not
-  /// support any other modification of the digraph.
-  ///
-  /// Since this digraph structure is completely static, its nodes and arcs
-  /// can be indexed with integers from the ranges <tt>[0..nodeNum()-1]</tt>
-  /// and <tt>[0..arcNum()-1]</tt>, respectively.
-  /// The index of an item is the same as its ID, it can be obtained
-  /// using the corresponding \ref index() or \ref concepts::Digraph::id()
-  /// "id()" function. A node or arc with a certain index can be obtained
-  /// using node() or arc().
-  ///
-  /// This type fully conforms to the \ref concepts::Digraph "Digraph concept".
-  /// Most of its member functions and nested classes are documented
-  /// only in the concept class.
-  ///
-  /// This class provides constant time counting for nodes and arcs.
-  ///
-  /// \sa concepts::Digraph
-  class StaticDigraph : public ExtendedStaticDigraphBase {
-  public:
-
-    typedef ExtendedStaticDigraphBase Parent;
-
-  public:
-
-    /// \brief Constructor
-    ///
-    /// Default constructor.
-    StaticDigraph() : Parent() {}
-
-    /// \brief The node with the given index.
-    ///
-    /// This function returns the node with the given index.
-    /// \sa index()
-    static Node node(int ix) { return Parent::nodeFromId(ix); }
-
-    /// \brief The arc with the given index.
-    ///
-    /// This function returns the arc with the given index.
-    /// \sa index()
-    static Arc arc(int ix) { return Parent::arcFromId(ix); }
-
-    /// \brief The index of the given node.
-    ///
-    /// This function returns the index of the the given node.
-    /// \sa node()
-    static int index(Node node) { return Parent::id(node); }
-
-    /// \brief The index of the given arc.
-    ///
-    /// This function returns the index of the the given arc.
-    /// \sa arc()
-    static int index(Arc arc) { return Parent::id(arc); }
-
-    /// \brief Number of nodes.
-    ///
-    /// This function returns the number of nodes.
-    int nodeNum() const { return node_num; }
-
-    /// \brief Number of arcs.
-    ///
-    /// This function returns the number of arcs.
-    int arcNum() const { return arc_num; }
-
-    /// \brief Build the digraph copying another digraph.
-    ///
-    /// This function builds the digraph copying another digraph of any
-    /// kind. It can be called more than once, but in such case, the whole
-    /// structure and all maps will be cleared and rebuilt.
-    ///
-    /// This method also makes possible to copy a digraph to a StaticDigraph
-    /// structure using \ref DigraphCopy.
-    ///
-    /// \param digraph An existing digraph to be copied.
-    /// \param nodeRef The node references will be copied into this map.
-    /// Its key type must be \c Digraph::Node and its value type must be
-    /// \c StaticDigraph::Node.
-    /// It must conform to the \ref concepts::ReadWriteMap "ReadWriteMap"
-    /// concept.
-    /// \param arcRef The arc references will be copied into this map.
-    /// Its key type must be \c Digraph::Arc and its value type must be
-    /// \c StaticDigraph::Arc.
-    /// It must conform to the \ref concepts::WriteMap "WriteMap" concept.
-    ///
-    /// \note If you do not need the arc references, then you could use
-    /// \ref NullMap for the last parameter. However the node references
-    /// are required by the function itself, thus they must be readable
-    /// from the map.
-    template <typename Digraph, typename NodeRefMap, typename ArcRefMap>
-    void build(const Digraph& digraph, NodeRefMap& nodeRef, ArcRefMap& arcRef) {
-      if (built) Parent::clear();
-      Parent::build(digraph, nodeRef, arcRef);
-    }
-
-    /// \brief Build the digraph from an arc list.
-    ///
-    /// This function builds the digraph from the given arc list.
-    /// It can be called more than once, but in such case, the whole
-    /// structure and all maps will be cleared and rebuilt.
-    ///
-    /// The list of the arcs must be given in the range <tt>[begin, end)</tt>
-    /// specified by STL compatible itartors whose \c value_type must be
-    /// <tt>std::pair<int,int></tt>.
-    /// Each arc must be specified by a pair of integer indices
-    /// from the range <tt>[0..n-1]</tt>. <i>The pairs must be in a
-    /// non-decreasing order with respect to their first values.</i>
-    /// If the k-th pair in the list is <tt>(i,j)</tt>, then
-    /// <tt>arc(k-1)</tt> will connect <tt>node(i)</tt> to <tt>node(j)</tt>.
-    ///
-    /// \param n The number of nodes.
-    /// \param begin An iterator pointing to the beginning of the arc list.
-    /// \param end An iterator pointing to the end of the arc list.
-    ///
-    /// For example, a simple digraph can be constructed like this.
-    /// \code
-    ///   std::vector<std::pair<int,int> > arcs;
-    ///   arcs.push_back(std::make_pair(0,1));
-    ///   arcs.push_back(std::make_pair(0,2));
-    ///   arcs.push_back(std::make_pair(1,3));
-    ///   arcs.push_back(std::make_pair(1,2));
-    ///   arcs.push_back(std::make_pair(3,0));
-    ///   StaticDigraph gr;
-    ///   gr.build(4, arcs.begin(), arcs.end());
-    /// \endcode
-    template <typename ArcListIterator>
-    void build(int n, ArcListIterator begin, ArcListIterator end) {
-      if (built) Parent::clear();
-      StaticDigraphBase::build(n, begin, end);
-      notifier(Node()).build();
-      notifier(Arc()).build();
-    }
-
-    /// \brief Clear the digraph.
-    ///
-    /// This function erases all nodes and arcs from the digraph.
-    void clear() {
-      Parent::clear();
-    }
-
-  protected:
-
-    using Parent::fastFirstOut;
-    using Parent::fastNextOut;
-    using Parent::fastLastOut;
-
-  public:
-
-    class OutArcIt : public Arc {
-    public:
-
-      OutArcIt() { }
-
-      OutArcIt(Invalid i) : Arc(i) { }
-
-      OutArcIt(const StaticDigraph& digraph, const Node& node) {
-        digraph.fastFirstOut(*this, node);
-        digraph.fastLastOut(last, node);
-        if (last == *this) *this = INVALID;
-      }
-
-      OutArcIt(const StaticDigraph& digraph, const Arc& arc) : Arc(arc) {
-        if (arc != INVALID) {
-          digraph.fastLastOut(last, digraph.source(arc));
-        }
-      }
-
-      OutArcIt& operator++() {
-        StaticDigraph::fastNextOut(*this);
-        if (last == *this) *this = INVALID;
-        return *this;
-      }
-
-    private:
-      Arc last;
-    };
-
-    Node baseNode(const OutArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-
-    Node runningNode(const OutArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-
-    Node baseNode(const InArcIt &arc) const {
-      return Parent::target(static_cast<const Arc&>(arc));
-    }
-
-    Node runningNode(const InArcIt &arc) const {
-      return Parent::source(static_cast<const Arc&>(arc));
-    }
-
-  };
-
-}
-
-#endif
Index: lemon/suurballe.h
===================================================================
--- lemon/suurballe.h	(revision 877)
+++ lemon/suurballe.h	(revision 852)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,51 +30,7 @@
 #include <lemon/path.h>
 #include <lemon/list_graph.h>
-#include <lemon/dijkstra.h>
 #include <lemon/maps.h>
 
 namespace lemon {
-
-  /// \brief Default traits class of Suurballe algorithm.
-  ///
-  /// Default traits class of Suurballe algorithm.
-  /// \tparam GR The digraph type the algorithm runs on.
-  /// \tparam LEN The type of the length map.
-  /// The default value is <tt>GR::ArcMap<int></tt>.
-#ifdef DOXYGEN
-  template <typename GR, typename LEN>
-#else
-  template < typename GR,
-             typename LEN = typename GR::template ArcMap<int> >
-#endif
-  struct SuurballeDefaultTraits
-  {
-    /// The type of the digraph.
-    typedef GR Digraph;
-    /// The type of the length map.
-    typedef LEN LengthMap;
-    /// The type of the lengths.
-    typedef typename LEN::Value Length;
-    /// The type of the flow map.
-    typedef typename GR::template ArcMap<int> FlowMap;
-    /// The type of the potential map.
-    typedef typename GR::template NodeMap<Length> PotentialMap;
-
-    /// \brief The path type
-    ///
-    /// The type used for storing the found arc-disjoint paths.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    typedef lemon::Path<Digraph> Path;
-
-    /// The cross reference type used for the heap.
-    typedef typename GR::template NodeMap<int> HeapCrossRef;
-
-    /// \brief The heap type used for internal Dijkstra computations.
-    ///
-    /// The type of the heap used for internal Dijkstra computations.
-    /// It must conform to the \ref lemon::concepts::Heap "Heap" concept
-    /// and its priority type must be \c Length.
-    typedef BinHeap<Length, HeapCrossRef> Heap;
-  };
 
   /// \addtogroup shortest_path
@@ -91,5 +47,5 @@
   /// "minimum cost flow problem". This implementation is actually an
   /// efficient specialized version of the \ref CapacityScaling
-  /// "successive shortest path" algorithm directly for this problem.
+  /// "Successive Shortest Path" algorithm directly for this problem.
   /// Therefore this class provides query functions for flow values and
   /// node potentials (the dual solution) just like the minimum cost flow
@@ -102,12 +58,11 @@
   /// \warning Length values should be \e non-negative.
   ///
-  /// \note For finding \e node-disjoint paths, this algorithm can be used
+  /// \note For finding node-disjoint paths this algorithm can be used
   /// along with the \ref SplitNodes adaptor.
 #ifdef DOXYGEN
-  template <typename GR, typename LEN, typename TR>
+  template <typename GR, typename LEN>
 #else
   template < typename GR,
-             typename LEN = typename GR::template ArcMap<int>,
-             typename TR = SuurballeDefaultTraits<GR, LEN> >
+             typename LEN = typename GR::template ArcMap<int> >
 #endif
   class Suurballe
@@ -120,24 +75,24 @@
   public:
 
-    /// The type of the digraph.
-    typedef typename TR::Digraph Digraph;
+    /// The type of the digraph the algorithm runs on.
+    typedef GR Digraph;
     /// The type of the length map.
-    typedef typename TR::LengthMap LengthMap;
+    typedef LEN LengthMap;
     /// The type of the lengths.
-    typedef typename TR::Length Length;
-
+    typedef typename LengthMap::Value Length;
+#ifdef DOXYGEN
     /// The type of the flow map.
-    typedef typename TR::FlowMap FlowMap;
+    typedef GR::ArcMap<int> FlowMap;
     /// The type of the potential map.
-    typedef typename TR::PotentialMap PotentialMap;
+    typedef GR::NodeMap<Length> PotentialMap;
+#else
+    /// The type of the flow map.
+    typedef typename Digraph::template ArcMap<int> FlowMap;
+    /// The type of the potential map.
+    typedef typename Digraph::template NodeMap<Length> PotentialMap;
+#endif
+
     /// The type of the path structures.
-    typedef typename TR::Path Path;
-    /// The cross reference type used for the heap.
-    typedef typename TR::HeapCrossRef HeapCrossRef;
-    /// The heap type used for internal Dijkstra computations.
-    typedef typename TR::Heap Heap;
-
-    /// The \ref SuurballeDefaultTraits "traits class" of the algorithm.
-    typedef TR Traits;
+    typedef SimplePath<GR> Path;
 
   private:
@@ -150,36 +105,42 @@
     class ResidualDijkstra
     {
+      typedef typename Digraph::template NodeMap<int> HeapCrossRef;
+      typedef BinHeap<Length, HeapCrossRef> Heap;
+
     private:
 
+      // The digraph the algorithm runs on
       const Digraph &_graph;
+
+      // The main maps
+      const FlowMap &_flow;
       const LengthMap &_length;
-      const FlowMap &_flow;
-      PotentialMap &_pi;
+      PotentialMap &_potential;
+
+      // The distance map
+      PotentialMap _dist;
+      // The pred arc map
       PredMap &_pred;
+      // The processed (i.e. permanently labeled) nodes
+      std::vector<Node> _proc_nodes;
+
       Node _s;
       Node _t;
 
-      PotentialMap _dist;
-      std::vector<Node> _proc_nodes;
-
     public:
 
-      // Constructor
-      ResidualDijkstra(Suurballe &srb) :
-        _graph(srb._graph), _length(srb._length),
-        _flow(*srb._flow), _pi(*srb._potential), _pred(srb._pred),
-        _s(srb._s), _t(srb._t), _dist(_graph) {}
-
-      // Run the algorithm and return true if a path is found
-      // from the source node to the target node.
-      bool run(int cnt) {
-        return cnt == 0 ? startFirst() : start();
-      }
-
-    private:
-
-      // Execute the algorithm for the first time (the flow and potential
-      // functions have to be identically zero).
-      bool startFirst() {
+      /// Constructor.
+      ResidualDijkstra( const Digraph &graph,
+                        const FlowMap &flow,
+                        const LengthMap &length,
+                        PotentialMap &potential,
+                        PredMap &pred,
+                        Node s, Node t ) :
+        _graph(graph), _flow(flow), _length(length), _potential(potential),
+        _dist(graph), _pred(pred), _s(s), _t(t) {}
+
+      /// \brief Run the algorithm. It returns \c true if a path is found
+      /// from the source node to the target node.
+      bool run() {
         HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
         Heap heap(heap_cross_ref);
@@ -191,21 +152,22 @@
         while (!heap.empty() && heap.top() != _t) {
           Node u = heap.top(), v;
-          Length d = heap.prio(), dn;
+          Length d = heap.prio() + _potential[u], nd;
           _dist[u] = heap.prio();
+          heap.pop();
           _proc_nodes.push_back(u);
-          heap.pop();
 
           // Traverse outgoing arcs
           for (OutArcIt e(_graph, u); e != INVALID; ++e) {
-            v = _graph.target(e);
-            switch(heap.state(v)) {
+            if (_flow[e] == 0) {
+              v = _graph.target(e);
+              switch(heap.state(v)) {
               case Heap::PRE_HEAP:
-                heap.push(v, d + _length[e]);
+                heap.push(v, d + _length[e] - _potential[v]);
                 _pred[v] = e;
                 break;
               case Heap::IN_HEAP:
-                dn = d + _length[e];
-                if (dn < heap[v]) {
-                  heap.decrease(v, dn);
+                nd = d + _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
                   _pred[v] = e;
                 }
@@ -213,50 +175,4 @@
               case Heap::POST_HEAP:
                 break;
-            }
-          }
-        }
-        if (heap.empty()) return false;
-
-        // Update potentials of processed nodes
-        Length t_dist = heap.prio();
-        for (int i = 0; i < int(_proc_nodes.size()); ++i)
-          _pi[_proc_nodes[i]] = _dist[_proc_nodes[i]] - t_dist;
-        return true;
-      }
-
-      // Execute the algorithm.
-      bool start() {
-        HeapCrossRef heap_cross_ref(_graph, Heap::PRE_HEAP);
-        Heap heap(heap_cross_ref);
-        heap.push(_s, 0);
-        _pred[_s] = INVALID;
-        _proc_nodes.clear();
-
-        // Process nodes
-        while (!heap.empty() && heap.top() != _t) {
-          Node u = heap.top(), v;
-          Length d = heap.prio() + _pi[u], dn;
-          _dist[u] = heap.prio();
-          _proc_nodes.push_back(u);
-          heap.pop();
-
-          // Traverse outgoing arcs
-          for (OutArcIt e(_graph, u); e != INVALID; ++e) {
-            if (_flow[e] == 0) {
-              v = _graph.target(e);
-              switch(heap.state(v)) {
-                case Heap::PRE_HEAP:
-                  heap.push(v, d + _length[e] - _pi[v]);
-                  _pred[v] = e;
-                  break;
-                case Heap::IN_HEAP:
-                  dn = d + _length[e] - _pi[v];
-                  if (dn < heap[v]) {
-                    heap.decrease(v, dn);
-                    _pred[v] = e;
-                  }
-                  break;
-                case Heap::POST_HEAP:
-                  break;
               }
             }
@@ -268,17 +184,17 @@
               v = _graph.source(e);
               switch(heap.state(v)) {
-                case Heap::PRE_HEAP:
-                  heap.push(v, d - _length[e] - _pi[v]);
+              case Heap::PRE_HEAP:
+                heap.push(v, d - _length[e] - _potential[v]);
+                _pred[v] = e;
+                break;
+              case Heap::IN_HEAP:
+                nd = d - _length[e] - _potential[v];
+                if (nd < heap[v]) {
+                  heap.decrease(v, nd);
                   _pred[v] = e;
-                  break;
-                case Heap::IN_HEAP:
-                  dn = d - _length[e] - _pi[v];
-                  if (dn < heap[v]) {
-                    heap.decrease(v, dn);
-                    _pred[v] = e;
-                  }
-                  break;
-                case Heap::POST_HEAP:
-                  break;
+                }
+                break;
+              case Heap::POST_HEAP:
+                break;
               }
             }
@@ -290,86 +206,9 @@
         Length t_dist = heap.prio();
         for (int i = 0; i < int(_proc_nodes.size()); ++i)
-          _pi[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
+          _potential[_proc_nodes[i]] += _dist[_proc_nodes[i]] - t_dist;
         return true;
       }
 
     }; //class ResidualDijkstra
-
-  public:
-
-    /// \name Named Template Parameters
-    /// @{
-
-    template <typename T>
-    struct SetFlowMapTraits : public Traits {
-      typedef T FlowMap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c FlowMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c FlowMap type.
-    template <typename T>
-    struct SetFlowMap
-      : public Suurballe<GR, LEN, SetFlowMapTraits<T> > {
-      typedef Suurballe<GR, LEN, SetFlowMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPotentialMapTraits : public Traits {
-      typedef T PotentialMap;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c PotentialMap type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting
-    /// \c PotentialMap type.
-    template <typename T>
-    struct SetPotentialMap
-      : public Suurballe<GR, LEN, SetPotentialMapTraits<T> > {
-      typedef Suurballe<GR, LEN, SetPotentialMapTraits<T> > Create;
-    };
-
-    template <typename T>
-    struct SetPathTraits : public Traits {
-      typedef T Path;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c %Path type.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c %Path type.
-    /// It must conform to the \ref lemon::concepts::Path "Path" concept
-    /// and it must have an \c addBack() function.
-    template <typename T>
-    struct SetPath
-      : public Suurballe<GR, LEN, SetPathTraits<T> > {
-      typedef Suurballe<GR, LEN, SetPathTraits<T> > Create;
-    };
-
-    template <typename H, typename CR>
-    struct SetHeapTraits : public Traits {
-      typedef H Heap;
-      typedef CR HeapCrossRef;
-    };
-
-    /// \brief \ref named-templ-param "Named parameter" for setting
-    /// \c Heap and \c HeapCrossRef types.
-    ///
-    /// \ref named-templ-param "Named parameter" for setting \c Heap
-    /// and \c HeapCrossRef types with automatic allocation.
-    /// They will be used for internal Dijkstra computations.
-    /// The heap type must conform to the \ref lemon::concepts::Heap "Heap"
-    /// concept and its priority type must be \c Length.
-    template <typename H,
-              typename CR = typename Digraph::template NodeMap<int> >
-    struct SetHeap
-      : public Suurballe<GR, LEN, SetHeapTraits<H, CR> > {
-      typedef Suurballe<GR, LEN, SetHeapTraits<H, CR> > Create;
-    };
-
-    /// @}
 
   private:
@@ -388,23 +227,17 @@
 
     // The source node
-    Node _s;
+    Node _source;
     // The target node
-    Node _t;
+    Node _target;
 
     // Container to store the found paths
-    std::vector<Path> _paths;
+    std::vector< SimplePath<Digraph> > paths;
     int _path_num;
 
     // The pred arc map
     PredMap _pred;
-
-    // Data for full init
-    PotentialMap *_init_dist;
-    PredMap *_init_pred;
-    bool _full_init;
-
-  protected:
-
-    Suurballe() {}
+    // Implementation of the Dijkstra algorithm for finding augmenting
+    // shortest paths in the residual network
+    ResidualDijkstra *_dijkstra;
 
   public:
@@ -419,6 +252,5 @@
                const LengthMap &length ) :
       _graph(graph), _length(length), _flow(0), _local_flow(false),
-      _potential(0), _local_potential(false), _pred(graph),
-      _init_dist(0), _init_pred(0)
+      _potential(0), _local_potential(false), _pred(graph)
     {}
 
@@ -427,6 +259,5 @@
       if (_local_flow) delete _flow;
       if (_local_potential) delete _potential;
-      delete _init_dist;
-      delete _init_pred;
+      delete _dijkstra;
     }
 
@@ -473,11 +304,8 @@
     /// \name Execution Control
     /// The simplest way to execute the algorithm is to call the run()
-    /// function.\n
-    /// If you need to execute the algorithm many times using the same
-    /// source node, then you may call fullInit() once and start()
-    /// for each target node.\n
+    /// function.
+    /// \n
     /// If you only need the flow that is the union of the found
-    /// arc-disjoint paths, then you may call findFlow() instead of
-    /// start().
+    /// arc-disjoint paths, you may call init() and findFlow().
 
     /// @{
@@ -499,9 +327,11 @@
     /// \code
     ///   s.init(s);
-    ///   s.start(t, k);
+    ///   s.findFlow(t, k);
+    ///   s.findPaths();
     /// \endcode
     int run(const Node& s, const Node& t, int k = 2) {
       init(s);
-      start(t, k);
+      findFlow(t, k);
+      findPaths();
       return _path_num;
     }
@@ -509,9 +339,9 @@
     /// \brief Initialize the algorithm.
     ///
-    /// This function initializes the algorithm with the given source node.
+    /// This function initializes the algorithm.
     ///
     /// \param s The source node.
     void init(const Node& s) {
-      _s = s;
+      _source = s;
 
       // Initialize maps
@@ -524,61 +354,6 @@
         _local_potential = true;
       }
-      _full_init = false;
-    }
-
-    /// \brief Initialize the algorithm and perform Dijkstra.
-    ///
-    /// This function initializes the algorithm and performs a full
-    /// Dijkstra search from the given source node. It makes consecutive
-    /// executions of \ref start() "start(t, k)" faster, since they
-    /// have to perform %Dijkstra only k-1 times.
-    ///
-    /// This initialization is usually worth using instead of \ref init()
-    /// if the algorithm is executed many times using the same source node.
-    ///
-    /// \param s The source node.
-    void fullInit(const Node& s) {
-      // Initialize maps
-      init(s);
-      if (!_init_dist) {
-        _init_dist = new PotentialMap(_graph);
-      }
-      if (!_init_pred) {
-        _init_pred = new PredMap(_graph);
-      }
-
-      // Run a full Dijkstra
-      typename Dijkstra<Digraph, LengthMap>
-        ::template SetStandardHeap<Heap>
-        ::template SetDistMap<PotentialMap>
-        ::template SetPredMap<PredMap>
-        ::Create dijk(_graph, _length);
-      dijk.distMap(*_init_dist).predMap(*_init_pred);
-      dijk.run(s);
-
-      _full_init = true;
-    }
-
-    /// \brief Execute the algorithm.
-    ///
-    /// This function executes the algorithm.
-    ///
-    /// \param t The target node.
-    /// \param k The number of paths to be found.
-    ///
-    /// \return \c k if there are at least \c k arc-disjoint paths from
-    /// \c s to \c t in the digraph. Otherwise it returns the number of
-    /// arc-disjoint paths found.
-    ///
-    /// \note Apart from the return value, <tt>s.start(t, k)</tt> is
-    /// just a shortcut of the following code.
-    /// \code
-    ///   s.findFlow(t, k);
-    ///   s.findPaths();
-    /// \endcode
-    int start(const Node& t, int k = 2) {
-      findFlow(t, k);
-      findPaths();
-      return _path_num;
+      for (ArcIt e(_graph); e != INVALID; ++e) (*_flow)[e] = 0;
+      for (NodeIt n(_graph); n != INVALID; ++n) (*_potential)[n] = 0;
     }
 
@@ -598,37 +373,18 @@
     /// \pre \ref init() must be called before using this function.
     int findFlow(const Node& t, int k = 2) {
-      _t = t;
-      ResidualDijkstra dijkstra(*this);
-
-      // Initialization
-      for (ArcIt e(_graph); e != INVALID; ++e) {
-        (*_flow)[e] = 0;
-      }
-      if (_full_init) {
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          (*_potential)[n] = (*_init_dist)[n];
-        }
-        Node u = _t;
-        Arc e;
-        while ((e = (*_init_pred)[u]) != INVALID) {
-          (*_flow)[e] = 1;
-          u = _graph.source(e);
-        }
-        _path_num = 1;
-      } else {
-        for (NodeIt n(_graph); n != INVALID; ++n) {
-          (*_potential)[n] = 0;
-        }
-        _path_num = 0;
-      }
+      _target = t;
+      _dijkstra =
+        new ResidualDijkstra( _graph, *_flow, _length, *_potential, _pred,
+                              _source, _target );
 
       // Find shortest paths
+      _path_num = 0;
       while (_path_num < k) {
         // Run Dijkstra
-        if (!dijkstra.run(_path_num)) break;
+        if (!_dijkstra->run()) break;
         ++_path_num;
 
         // Set the flow along the found shortest path
-        Node u = _t;
+        Node u = _target;
         Arc e;
         while ((e = _pred[u]) != INVALID) {
@@ -647,6 +403,6 @@
     /// \brief Compute the paths from the flow.
     ///
-    /// This function computes arc-disjoint paths from the found minimum
-    /// cost flow, which is the union of them.
+    /// This function computes the paths from the found minimum cost flow,
+    /// which is the union of some arc-disjoint paths.
     ///
     /// \pre \ref init() and \ref findFlow() must be called before using
@@ -656,13 +412,13 @@
       for(ArcIt a(_graph); a != INVALID; ++a) res_flow[a] = (*_flow)[a];
 
-      _paths.clear();
-      _paths.resize(_path_num);
+      paths.clear();
+      paths.resize(_path_num);
       for (int i = 0; i < _path_num; ++i) {
-        Node n = _s;
-        while (n != _t) {
+        Node n = _source;
+        while (n != _target) {
           OutArcIt e(_graph, n);
           for ( ; res_flow[e] == 0; ++e) ;
           n = _graph.target(e);
-          _paths[i].addBack(e);
+          paths[i].addBack(e);
           res_flow[e] = 0;
         }
@@ -763,5 +519,5 @@
     /// this function.
     const Path& path(int i) const {
-      return _paths[i];
+      return paths[i];
     }
 
Index: lemon/time_measure.h
===================================================================
--- lemon/time_measure.h	(revision 786)
+++ lemon/time_measure.h	(revision 584)
@@ -376,5 +376,5 @@
     ///This function returns the number of stop() exections that is
     ///necessary to really stop the timer.
-    ///For example, the timer
+    ///For example the timer
     ///is running if and only if the return value is \c true
     ///(i.e. greater than
Index: lemon/unionfind.h
===================================================================
--- lemon/unionfind.h	(revision 877)
+++ lemon/unionfind.h	(revision 867)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -44,5 +44,5 @@
   /// This is a very simple but efficient implementation, providing
   /// only four methods: join (union), find, insert and size.
-  /// For more features, see the \ref UnionFindEnum class.
+  /// For more features see the \ref UnionFindEnum class.
   ///
   /// It is primarily used in Kruskal algorithm for finding minimal
Index: m4/lx_check_coin.m4
===================================================================
--- m4/lx_check_coin.m4	(revision 749)
+++ m4/lx_check_coin.m4	(revision 749)
@@ -0,0 +1,136 @@
+AC_DEFUN([LX_CHECK_COIN],
+[
+  AC_ARG_WITH([coin],
+AS_HELP_STRING([--with-coin@<:@=PREFIX@:>@], [search for CLP under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-coin], [disable checking for CLP]),
+              [], [with_coin=yes])
+
+  AC_ARG_WITH([coin-includedir],
+AS_HELP_STRING([--with-coin-includedir=DIR], [search for CLP headers in DIR]),
+              [], [with_coin_includedir=no])
+
+  AC_ARG_WITH([coin-libdir],
+AS_HELP_STRING([--with-coin-libdir=DIR], [search for CLP libraries in DIR]),
+              [], [with_coin_libdir=no])
+
+  lx_clp_found=no
+  if test x"$with_coin" != x"no"; then
+    AC_MSG_CHECKING([for CLP])
+
+    if test x"$with_coin_includedir" != x"no"; then
+      CLP_CXXFLAGS="-I$with_coin_includedir"
+    elif test x"$with_coin" != x"yes"; then
+      CLP_CXXFLAGS="-I$with_coin/include"
+    fi
+
+    if test x"$with_coin_libdir" != x"no"; then
+      CLP_LDFLAGS="-L$with_coin_libdir"
+    elif test x"$with_coin" != x"yes"; then
+      CLP_LDFLAGS="-L$with_coin/lib"
+    fi
+    CLP_LIBS="-lClp -lCoinUtils -lm"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$CLP_CXXFLAGS"
+    LDFLAGS="$CLP_LDFLAGS"
+    LIBS="$CLP_LIBS"
+
+    lx_clp_test_prog='
+      #include <coin/ClpModel.hpp>
+
+      int main(int argc, char** argv)
+      {
+        ClpModel clp;
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_clp_test_prog], [lx_clp_found=yes], [lx_clp_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_clp_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_CLP], [1], [Define to 1 if you have CLP.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      CLP_CXXFLAGS=""
+      CLP_LDFLAGS=""
+      CLP_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  CLP_LIBS="$CLP_LDFLAGS $CLP_LIBS"
+  AC_SUBST(CLP_CXXFLAGS)
+  AC_SUBST(CLP_LIBS)
+  AM_CONDITIONAL([HAVE_CLP], [test x"$lx_clp_found" = x"yes"])
+
+
+  lx_cbc_found=no
+  if test x"$lx_clp_found" = x"yes"; then
+    if test x"$with_coin" != x"no"; then
+      AC_MSG_CHECKING([for CBC])
+
+      if test x"$with_coin_includedir" != x"no"; then
+        CBC_CXXFLAGS="-I$with_coin_includedir"
+      elif test x"$with_coin" != x"yes"; then
+        CBC_CXXFLAGS="-I$with_coin/include"
+      fi
+
+      if test x"$with_coin_libdir" != x"no"; then
+        CBC_LDFLAGS="-L$with_coin_libdir"
+      elif test x"$with_coin" != x"yes"; then
+        CBC_LDFLAGS="-L$with_coin/lib"
+      fi
+      CBC_LIBS="-lOsi -lCbc -lCbcSolver -lClp -lOsiClp -lCoinUtils -lVol -lOsiVol -lCgl -lm -llapack -lblas"
+
+      lx_save_cxxflags="$CXXFLAGS"
+      lx_save_ldflags="$LDFLAGS"
+      lx_save_libs="$LIBS"
+      CXXFLAGS="$CBC_CXXFLAGS"
+      LDFLAGS="$CBC_LDFLAGS"
+      LIBS="$CBC_LIBS"
+
+      lx_cbc_test_prog='
+        #include <coin/CbcModel.hpp>
+
+        int main(int argc, char** argv)
+        {
+          CbcModel cbc;
+          return 0;
+        }'
+
+      AC_LANG_PUSH(C++)
+      AC_LINK_IFELSE([$lx_cbc_test_prog], [lx_cbc_found=yes], [lx_cbc_found=no])
+      AC_LANG_POP(C++)
+
+      CXXFLAGS="$lx_save_cxxflags"
+      LDFLAGS="$lx_save_ldflags"
+      LIBS="$lx_save_libs"
+
+      if test x"$lx_cbc_found" = x"yes"; then
+        AC_DEFINE([LEMON_HAVE_CBC], [1], [Define to 1 if you have CBC.])
+        lx_lp_found=yes
+        AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+        lx_mip_found=yes
+        AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
+        AC_MSG_RESULT([yes])
+      else
+        CBC_CXXFLAGS=""
+        CBC_LDFLAGS=""
+        CBC_LIBS=""
+        AC_MSG_RESULT([no])
+      fi
+    fi
+  fi
+  CBC_LIBS="$CBC_LDFLAGS $CBC_LIBS"
+  AC_SUBST(CBC_CXXFLAGS)
+  AC_SUBST(CBC_LIBS)
+  AM_CONDITIONAL([HAVE_CBC], [test x"$lx_cbc_found" = x"yes"])
+])
Index: m4/lx_check_cplex.m4
===================================================================
--- m4/lx_check_cplex.m4	(revision 627)
+++ m4/lx_check_cplex.m4	(revision 627)
@@ -0,0 +1,81 @@
+AC_DEFUN([LX_CHECK_CPLEX],
+[
+  AC_ARG_WITH([cplex],
+AS_HELP_STRING([--with-cplex@<:@=PREFIX@:>@], [search for CPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-cplex], [disable checking for CPLEX]),
+              [], [with_cplex=yes])
+
+  AC_ARG_WITH([cplex-includedir],
+AS_HELP_STRING([--with-cplex-includedir=DIR], [search for CPLEX headers in DIR]),
+              [], [with_cplex_includedir=no])
+
+  AC_ARG_WITH([cplex-libdir],
+AS_HELP_STRING([--with-cplex-libdir=DIR], [search for CPLEX libraries in DIR]),
+              [], [with_cplex_libdir=no])
+
+  lx_cplex_found=no
+  if test x"$with_cplex" != x"no"; then
+    AC_MSG_CHECKING([for CPLEX])
+
+    if test x"$with_cplex_includedir" != x"no"; then
+      CPLEX_CFLAGS="-I$with_cplex_includedir"
+    elif test x"$with_cplex" != x"yes"; then
+      CPLEX_CFLAGS="-I$with_cplex/include"
+    elif test x"$CPLEX_INCLUDEDIR" != x; then
+      CPLEX_CFLAGS="-I$CPLEX_INCLUDEDIR"
+    fi
+
+    if test x"$with_cplex_libdir" != x"no"; then
+      CPLEX_LDFLAGS="-L$with_cplex_libdir"
+    elif test x"$with_cplex" != x"yes"; then
+      CPLEX_LDFLAGS="-L$with_cplex/lib"
+    elif test x"$CPLEX_LIBDIR" != x; then
+      CPLEX_LDFLAGS="-L$CPLEX_LIBDIR"
+    fi
+    CPLEX_LIBS="-lcplex -lm -lpthread"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$CPLEX_CFLAGS"
+    LDFLAGS="$CPLEX_LDFLAGS"
+    LIBS="$CPLEX_LIBS"
+
+    lx_cplex_test_prog='
+      extern "C" {
+      #include <ilcplex/cplex.h>
+      }
+
+      int main(int argc, char** argv)
+      {
+        CPXENVptr env = NULL;
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_cplex_test_prog], [lx_cplex_found=yes], [lx_cplex_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_cplex_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_CPLEX], [1], [Define to 1 if you have CPLEX.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      lx_mip_found=yes
+      AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      CPLEX_CFLAGS=""
+      CPLEX_LDFLAGS=""
+      CPLEX_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  CPLEX_LIBS="$CPLEX_LDFLAGS $CPLEX_LIBS"
+  AC_SUBST(CPLEX_CFLAGS)
+  AC_SUBST(CPLEX_LIBS)
+  AM_CONDITIONAL([HAVE_CPLEX], [test x"$lx_cplex_found" = x"yes"])
+])
Index: m4/lx_check_glpk.m4
===================================================================
--- m4/lx_check_glpk.m4	(revision 627)
+++ m4/lx_check_glpk.m4	(revision 627)
@@ -0,0 +1,84 @@
+AC_DEFUN([LX_CHECK_GLPK],
+[
+  AC_ARG_WITH([glpk],
+AS_HELP_STRING([--with-glpk@<:@=PREFIX@:>@], [search for GLPK under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-glpk], [disable checking for GLPK]),
+              [], [with_glpk=yes])
+
+  AC_ARG_WITH([glpk-includedir],
+AS_HELP_STRING([--with-glpk-includedir=DIR], [search for GLPK headers in DIR]),
+              [], [with_glpk_includedir=no])
+
+  AC_ARG_WITH([glpk-libdir],
+AS_HELP_STRING([--with-glpk-libdir=DIR], [search for GLPK libraries in DIR]),
+              [], [with_glpk_libdir=no])
+
+  lx_glpk_found=no
+  if test x"$with_glpk" != x"no"; then
+    AC_MSG_CHECKING([for GLPK])
+
+    if test x"$with_glpk_includedir" != x"no"; then
+      GLPK_CFLAGS="-I$with_glpk_includedir"
+    elif test x"$with_glpk" != x"yes"; then
+      GLPK_CFLAGS="-I$with_glpk/include"
+    fi
+
+    if test x"$with_glpk_libdir" != x"no"; then
+      GLPK_LDFLAGS="-L$with_glpk_libdir"
+    elif test x"$with_glpk" != x"yes"; then
+      GLPK_LDFLAGS="-L$with_glpk/lib"
+    fi
+    GLPK_LIBS="-lglpk"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$GLPK_CFLAGS"
+    LDFLAGS="$GLPK_LDFLAGS"
+    LIBS="$GLPK_LIBS"
+
+    lx_glpk_test_prog='
+      extern "C" {
+      #include <glpk.h>
+      }
+
+      #if (GLP_MAJOR_VERSION < 4) \
+         || (GLP_MAJOR_VERSION == 4 && GLP_MINOR_VERSION < 33)
+      #error Supported GLPK versions: 4.33 or above
+      #endif
+
+      int main(int argc, char** argv)
+      {
+        LPX *lp;
+        lp = lpx_create_prob();
+        lpx_delete_prob(lp);
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_glpk_test_prog], [lx_glpk_found=yes], [lx_glpk_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_glpk_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_GLPK], [1], [Define to 1 if you have GLPK.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      lx_mip_found=yes
+      AC_DEFINE([LEMON_HAVE_MIP], [1], [Define to 1 if you have any MIP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      GLPK_CFLAGS=""
+      GLPK_LDFLAGS=""
+      GLPK_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  GLPK_LIBS="$GLPK_LDFLAGS $GLPK_LIBS"
+  AC_SUBST(GLPK_CFLAGS)
+  AC_SUBST(GLPK_LIBS)
+  AM_CONDITIONAL([HAVE_GLPK], [test x"$lx_glpk_found" = x"yes"])
+])
Index: m4/lx_check_soplex.m4
===================================================================
--- m4/lx_check_soplex.m4	(revision 627)
+++ m4/lx_check_soplex.m4	(revision 627)
@@ -0,0 +1,73 @@
+AC_DEFUN([LX_CHECK_SOPLEX],
+[
+  AC_ARG_WITH([soplex],
+AS_HELP_STRING([--with-soplex@<:@=PREFIX@:>@], [search for SOPLEX under PREFIX or under the default search paths if PREFIX is not given @<:@default@:>@])
+AS_HELP_STRING([--without-soplex], [disable checking for SOPLEX]),
+              [], [with_soplex=yes])
+
+  AC_ARG_WITH([soplex-includedir],
+AS_HELP_STRING([--with-soplex-includedir=DIR], [search for SOPLEX headers in DIR]),
+              [], [with_soplex_includedir=no])
+
+  AC_ARG_WITH([soplex-libdir],
+AS_HELP_STRING([--with-soplex-libdir=DIR], [search for SOPLEX libraries in DIR]),
+              [], [with_soplex_libdir=no])
+
+  lx_soplex_found=no
+  if test x"$with_soplex" != x"no"; then
+    AC_MSG_CHECKING([for SOPLEX])
+
+    if test x"$with_soplex_includedir" != x"no"; then
+      SOPLEX_CXXFLAGS="-I$with_soplex_includedir"
+    elif test x"$with_soplex" != x"yes"; then
+      SOPLEX_CXXFLAGS="-I$with_soplex/src"
+    fi
+
+    if test x"$with_soplex_libdir" != x"no"; then
+      SOPLEX_LDFLAGS="-L$with_soplex_libdir"
+    elif test x"$with_soplex" != x"yes"; then
+      SOPLEX_LDFLAGS="-L$with_soplex/lib"
+    fi
+    SOPLEX_LIBS="-lsoplex -lz"
+
+    lx_save_cxxflags="$CXXFLAGS"
+    lx_save_ldflags="$LDFLAGS"
+    lx_save_libs="$LIBS"
+    CXXFLAGS="$SOPLEX_CXXFLAGS"
+    LDFLAGS="$SOPLEX_LDFLAGS"
+    LIBS="$SOPLEX_LIBS"
+
+    lx_soplex_test_prog='
+      #include <soplex.h>
+
+      int main(int argc, char** argv)
+      {
+        soplex::SoPlex soplex;
+        return 0;
+      }'
+
+    AC_LANG_PUSH(C++)
+    AC_LINK_IFELSE([$lx_soplex_test_prog], [lx_soplex_found=yes], [lx_soplex_found=no])
+    AC_LANG_POP(C++)
+
+    CXXFLAGS="$lx_save_cxxflags"
+    LDFLAGS="$lx_save_ldflags"
+    LIBS="$lx_save_libs"
+
+    if test x"$lx_soplex_found" = x"yes"; then
+      AC_DEFINE([LEMON_HAVE_SOPLEX], [1], [Define to 1 if you have SOPLEX.])
+      lx_lp_found=yes
+      AC_DEFINE([LEMON_HAVE_LP], [1], [Define to 1 if you have any LP solver.])
+      AC_MSG_RESULT([yes])
+    else
+      SOPLEX_CXXFLAGS=""
+      SOPLEX_LDFLAGS=""
+      SOPLEX_LIBS=""
+      AC_MSG_RESULT([no])
+    fi
+  fi
+  SOPLEX_LIBS="$SOPLEX_LDFLAGS $SOPLEX_LIBS"
+  AC_SUBST(SOPLEX_CXXFLAGS)
+  AC_SUBST(SOPLEX_LIBS)
+  AM_CONDITIONAL([HAVE_SOPLEX], [test x"$lx_soplex_found" = x"yes"])
+])
Index: ripts/bib2dox.py
===================================================================
--- scripts/bib2dox.py	(revision 836)
+++ 	(revision )
@@ -1,816 +1,0 @@
-#! /usr/bin/env python
-"""
-  BibTeX to Doxygen converter
-  Usage: python bib2dox.py bibfile.bib > bibfile.dox
-
-  This file is a part of LEMON, a generic C++ optimization library.
-
-  **********************************************************************
-
-  This code is the modification of the BibTeX to XML converter
-  by Vidar Bronken Gundersen et al.
-  See the original copyright notices below. 
-
-  **********************************************************************
-
-  Decoder for bibliographic data, BibTeX
-  Usage: python bibtex2xml.py bibfile.bib > bibfile.xml
-
-  v.8
-  (c)2002-06-23 Vidar Bronken Gundersen
-  http://bibtexml.sf.net/
-  Reuse approved as long as this notification is kept.
-  Licence: GPL.
-
-  Contributions/thanks to:
-  Egon Willighagen, http://sf.net/projects/jreferences/
-  Richard Mahoney (for providing a test case)
-
-  Editted by Sara Sprenkle to be more robust and handle more bibtex features.
-  (c) 2003-01-15
-
-  1.  Changed bibtex: tags to bibxml: tags.
-  2.  Use xmlns:bibxml="http://bibtexml.sf.net/"
-  3.  Allow spaces between @type and first {
-  4.  "author" fields with multiple authors split by " and "
-      are put in separate xml "bibxml:author" tags.
-  5.  Option for Titles: words are capitalized
-      only if first letter in title or capitalized inside braces
-  6.  Removes braces from within field values
-  7.  Ignores comments in bibtex file (including @comment{ or % )
-  8.  Replaces some special latex tags, e.g., replaces ~ with '&#160;'
-  9.  Handles bibtex @string abbreviations
-        --> includes bibtex's default abbreviations for months
-        --> does concatenation of abbr # " more " and " more " # abbr
-  10. Handles @type( ... ) or @type{ ... }
-  11. The keywords field is split on , or ; and put into separate xml
-      "bibxml:keywords" tags
-  12. Ignores @preamble
-
-  Known Limitations
-  1.  Does not transform Latex encoding like math mode and special
-      latex symbols.
-  2.  Does not parse author fields into first and last names.
-      E.g., It does not do anything special to an author whose name is
-      in the form LAST_NAME, FIRST_NAME
-      In "author" tag, will show up as
-      <bibxml:author>LAST_NAME, FIRST_NAME</bibxml:author>
-  3.  Does not handle "crossref" fields other than to print
-      <bibxml:crossref>...</bibxml:crossref>
-  4.  Does not inform user of the input's format errors.  You just won't
-      be able to transform the file later with XSL
-
-  You will have to manually edit the XML output if you need to handle
-  these (and unknown) limitations.
-
-"""
-
-import string, re
-
-# set of valid name characters
-valid_name_chars = '[\w\-:]'
-
-#
-# define global regular expression variables
-#
-author_rex = re.compile('\s+and\s+')
-rembraces_rex = re.compile('[{}]')
-capitalize_rex = re.compile('({[^}]*})')
-
-# used by bibtexkeywords(data)
-keywords_rex = re.compile('[,;]')
-
-# used by concat_line(line)
-concatsplit_rex = re.compile('\s*#\s*')
-
-# split on {, }, or " in verify_out_of_braces
-delimiter_rex = re.compile('([{}"])',re.I)
-
-field_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
-data_rex = re.compile('\s*(\w*)\s*=\s*([^,]*),?')
-
-url_rex = re.compile('\\\url\{([^}]*)\}')
-
-#
-# styles for html formatting
-#
-divstyle = 'margin-top: -4ex; margin-left: 8em;'
-
-#
-# return the string parameter without braces
-#
-def transformurls(str):
-    return url_rex.sub(r'<a href="\1">\1</a>', str)
-
-#
-# return the string parameter without braces
-#
-def removebraces(str):
-    return rembraces_rex.sub('', str)
-
-#
-# latex-specific replacements
-# (do this after braces were removed)
-#
-def latexreplacements(line):
-    line = string.replace(line, '~', '&nbsp;')
-    line = string.replace(line, '\\\'a', '&aacute;')
-    line = string.replace(line, '\\"a', '&auml;')
-    line = string.replace(line, '\\\'e', '&eacute;')
-    line = string.replace(line, '\\"e', '&euml;')
-    line = string.replace(line, '\\\'i', '&iacute;')
-    line = string.replace(line, '\\"i', '&iuml;')
-    line = string.replace(line, '\\\'o', '&oacute;')
-    line = string.replace(line, '\\"o', '&ouml;')
-    line = string.replace(line, '\\\'u', '&uacute;')
-    line = string.replace(line, '\\"u', '&uuml;')
-    line = string.replace(line, '\\H o', '&otilde;')
-    line = string.replace(line, '\\H u', '&uuml;')   # &utilde; does not exist
-    line = string.replace(line, '\\\'A', '&Aacute;')
-    line = string.replace(line, '\\"A', '&Auml;')
-    line = string.replace(line, '\\\'E', '&Eacute;')
-    line = string.replace(line, '\\"E', '&Euml;')
-    line = string.replace(line, '\\\'I', '&Iacute;')
-    line = string.replace(line, '\\"I', '&Iuml;')
-    line = string.replace(line, '\\\'O', '&Oacute;')
-    line = string.replace(line, '\\"O', '&Ouml;')
-    line = string.replace(line, '\\\'U', '&Uacute;')
-    line = string.replace(line, '\\"U', '&Uuml;')
-    line = string.replace(line, '\\H O', '&Otilde;')
-    line = string.replace(line, '\\H U', '&Uuml;')   # &Utilde; does not exist
-
-    return line
-
-#
-# copy characters form a string decoding html expressions (&xyz;)
-#
-def copychars(str, ifrom, count):
-    result = ''
-    i = ifrom
-    c = 0
-    html_spec = False
-    while (i < len(str)) and (c < count):
-        if str[i] == '&':
-            html_spec = True;
-            if i+1 < len(str):
-                result += str[i+1]
-            c += 1
-            i += 2
-        else:
-            if not html_spec:
-                if ((str[i] >= 'A') and (str[i] <= 'Z')) or \
-                   ((str[i] >= 'a') and (str[i] <= 'z')):
-                    result += str[i]
-                    c += 1
-            elif str[i] == ';':
-                html_spec = False;
-            i += 1
-    
-    return result
-
-
-# 
-# Handle a list of authors (separated by 'and').
-# It gives back an array of the follwing values:
-#  - num: the number of authors,
-#  - list: the list of the author names,
-#  - text: the bibtex text (separated by commas and/or 'and')
-#  - abbrev: abbreviation that can be used for indicate the
-#    bibliography entries
-#
-def bibtexauthor(data):
-    result = {}
-    bibtex = ''
-    result['list'] = author_rex.split(data)
-    result['num'] = len(result['list'])
-    for i, author in enumerate(result['list']):
-        # general transformations
-        author = latexreplacements(removebraces(author.strip()))
-        # transform "Xyz, A. B." to "A. B. Xyz"
-        pos = author.find(',')
-        if pos != -1:
-            author = author[pos+1:].strip() + ' ' + author[:pos].strip()
-        result['list'][i] = author
-        bibtex += author + '#'
-    bibtex = bibtex[:-1]
-    if result['num'] > 1:
-        ix = bibtex.rfind('#')
-        if result['num'] == 2:
-            bibtex = bibtex[:ix] + ' and ' + bibtex[ix+1:]
-        else:
-            bibtex = bibtex[:ix] + ', and ' + bibtex[ix+1:]
-    bibtex = bibtex.replace('#', ', ')
-    result['text'] = bibtex
-    
-    result['abbrev'] = ''
-    for author in result['list']:
-        pos = author.rfind(' ') + 1
-        count = 1
-        if result['num'] == 1:
-            count = 3
-        result['abbrev'] += copychars(author, pos, count)
-
-    return result
-
-
-#
-# data = title string
-# @return the capitalized title (first letter is capitalized), rest are capitalized
-# only if capitalized inside braces
-#
-def capitalizetitle(data):
-    title_list = capitalize_rex.split(data)
-    title = ''
-    count = 0
-    for phrase in title_list:
-         check = string.lstrip(phrase)
-
-         # keep phrase's capitalization the same
-         if check.find('{') == 0:
-              title += removebraces(phrase)
-         else:
-         # first word --> capitalize first letter (after spaces)
-              if count == 0:
-                  title += check.capitalize()
-              else:
-                  title += phrase.lower()
-         count = count + 1
-
-    return title
-
-
-#
-# @return the bibtex for the title
-# @param data --> title string
-# braces are removed from title
-#
-def bibtextitle(data, entrytype):
-    if entrytype in ('book', 'inbook'):
-        title = removebraces(data.strip())
-    else:
-        title = removebraces(capitalizetitle(data.strip()))
-    bibtex = title
-    return bibtex
-
-
-#
-# function to compare entry lists
-#
-def entry_cmp(x, y):
-    return cmp(x[0], y[0])
-
-
-#
-# print the XML for the transformed "filecont_source"
-#
-def bibtexdecoder(filecont_source):
-    filecont = []
-    file = []
-    
-    # want @<alphanumeric chars><spaces>{<spaces><any chars>,
-    pubtype_rex = re.compile('@(\w*)\s*{\s*(.*),')
-    endtype_rex = re.compile('}\s*$')
-    endtag_rex = re.compile('^\s*}\s*$')
-
-    bracefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
-    bracedata_rex = re.compile('\s*(\w*)\s*=\s*{(.*)},?')
-
-    quotefield_rex = re.compile('\s*(\w*)\s*=\s*(.*)')
-    quotedata_rex = re.compile('\s*(\w*)\s*=\s*"(.*)",?')
-
-    for line in filecont_source:
-        line = line[:-1]
-
-        # encode character entities
-        line = string.replace(line, '&', '&amp;')
-        line = string.replace(line, '<', '&lt;')
-        line = string.replace(line, '>', '&gt;')
-
-        # start entry: publication type (store for later use)
-        if pubtype_rex.match(line):
-        # want @<alphanumeric chars><spaces>{<spaces><any chars>,
-            entrycont = {}
-            entry = []
-            entrytype = pubtype_rex.sub('\g<1>',line)
-            entrytype = string.lower(entrytype)
-            entryid   = pubtype_rex.sub('\g<2>', line)
-
-        # end entry if just a }
-        elif endtype_rex.match(line):
-            # generate doxygen code for the entry
-
-            # enty type related formattings
-            if entrytype in ('book', 'inbook'):
-                entrycont['title'] = '<em>' + entrycont['title'] + '</em>'
-                if not entrycont.has_key('author'):
-                    entrycont['author'] = entrycont['editor']
-                    entrycont['author']['text'] += ', editors'
-            elif entrytype == 'article':
-                entrycont['journal'] = '<em>' + entrycont['journal'] + '</em>'
-            elif entrytype in ('inproceedings', 'incollection', 'conference'):
-                entrycont['booktitle'] = '<em>' + entrycont['booktitle'] + '</em>'
-            elif entrytype == 'techreport':
-                if not entrycont.has_key('type'):
-                    entrycont['type'] = 'Technical report'
-            elif entrytype == 'mastersthesis':
-                entrycont['type'] = 'Master\'s thesis'
-            elif entrytype == 'phdthesis':
-                entrycont['type'] = 'PhD thesis'
-
-            for eline in entrycont:
-                if eline != '':
-                    eline = latexreplacements(eline)
-
-            if entrycont.has_key('pages') and (entrycont['pages'] != ''):
-                entrycont['pages'] = string.replace(entrycont['pages'], '--', '-')
-
-            if entrycont.has_key('author') and (entrycont['author'] != ''):
-                entry.append(entrycont['author']['text'] + '.')
-            if entrycont.has_key('title') and (entrycont['title'] != ''):
-                entry.append(entrycont['title'] + '.')
-            if entrycont.has_key('journal') and (entrycont['journal'] != ''):
-                entry.append(entrycont['journal'] + ',')
-            if entrycont.has_key('booktitle') and (entrycont['booktitle'] != ''):
-                entry.append('In ' + entrycont['booktitle'] + ',')
-            if entrycont.has_key('type') and (entrycont['type'] != ''):
-                eline = entrycont['type']
-                if entrycont.has_key('number') and (entrycont['number'] != ''):
-                    eline += ' ' + entrycont['number']
-                eline += ','
-                entry.append(eline)
-            if entrycont.has_key('institution') and (entrycont['institution'] != ''):
-                entry.append(entrycont['institution'] + ',')
-            if entrycont.has_key('publisher') and (entrycont['publisher'] != ''):
-                entry.append(entrycont['publisher'] + ',')
-            if entrycont.has_key('school') and (entrycont['school'] != ''):
-                entry.append(entrycont['school'] + ',')
-            if entrycont.has_key('address') and (entrycont['address'] != ''):
-                entry.append(entrycont['address'] + ',')
-            if entrycont.has_key('edition') and (entrycont['edition'] != ''):
-                entry.append(entrycont['edition'] + ' edition,')
-            if entrycont.has_key('howpublished') and (entrycont['howpublished'] != ''):
-                entry.append(entrycont['howpublished'] + ',')
-            if entrycont.has_key('volume') and (entrycont['volume'] != ''):
-                eline = entrycont['volume'];
-                if entrycont.has_key('number') and (entrycont['number'] != ''):
-                    eline += '(' + entrycont['number'] + ')'
-                if entrycont.has_key('pages') and (entrycont['pages'] != ''):
-                    eline += ':' + entrycont['pages']
-                eline += ','
-                entry.append(eline)
-            else:
-                if entrycont.has_key('pages') and (entrycont['pages'] != ''):
-                    entry.append('pages ' + entrycont['pages'] + ',')
-            if entrycont.has_key('year') and (entrycont['year'] != ''):
-                if entrycont.has_key('month') and (entrycont['month'] != ''):
-                    entry.append(entrycont['month'] + ' ' + entrycont['year'] + '.')
-                else:
-                    entry.append(entrycont['year'] + '.')
-            if entrycont.has_key('note') and (entrycont['note'] != ''):
-                entry.append(entrycont['note'] + '.')
-            if entrycont.has_key('url') and (entrycont['url'] != ''):
-                entry.append(entrycont['url'] + '.')
-
-            # generate keys for sorting and for the output
-            sortkey = ''
-            bibkey = ''
-            if entrycont.has_key('author'):
-                for author in entrycont['author']['list']:
-                    sortkey += copychars(author, author.rfind(' ')+1, len(author))
-                bibkey = entrycont['author']['abbrev']
-            else:
-                bibkey = 'x'
-            if entrycont.has_key('year'):
-                sortkey += entrycont['year']
-                bibkey += entrycont['year'][-2:]
-            if entrycont.has_key('title'):
-                sortkey += entrycont['title']
-            if entrycont.has_key('key'):
-                sortkey = entrycont['key'] + sortkey
-                bibkey = entrycont['key']
-            entry.insert(0, sortkey)
-            entry.insert(1, bibkey)
-            entry.insert(2, entryid)
-           
-            # add the entry to the file contents
-            filecont.append(entry)
-
-        else:
-            # field, publication info
-            field = ''
-            data = ''
-            
-            # field = {data} entries
-            if bracedata_rex.match(line):
-                field = bracefield_rex.sub('\g<1>', line)
-                field = string.lower(field)
-                data =  bracedata_rex.sub('\g<2>', line)
-
-            # field = "data" entries
-            elif quotedata_rex.match(line):
-                field = quotefield_rex.sub('\g<1>', line)
-                field = string.lower(field)
-                data =  quotedata_rex.sub('\g<2>', line)
-
-            # field = data entries
-            elif data_rex.match(line):
-                field = field_rex.sub('\g<1>', line)
-                field = string.lower(field)
-                data =  data_rex.sub('\g<2>', line)
-
-            if field == 'url':
-                data = '\\url{' + data.strip() + '}'
-            
-            if field in ('author', 'editor'):
-                entrycont[field] = bibtexauthor(data)
-                line = ''
-            elif field == 'title':
-                line = bibtextitle(data, entrytype)
-            elif field != '':
-                line = removebraces(transformurls(data.strip()))
-
-            if line != '':
-                line = latexreplacements(line)
-                entrycont[field] = line
-
-
-    # sort entries
-    filecont.sort(entry_cmp)
-    
-    # count the bibtex keys
-    keytable = {}
-    counttable = {}
-    for entry in filecont:
-        bibkey = entry[1]
-        if not keytable.has_key(bibkey):
-            keytable[bibkey] = 1
-        else:
-            keytable[bibkey] += 1
-
-    for bibkey in keytable.keys():
-        counttable[bibkey] = 0
-    
-    # generate output
-    for entry in filecont:
-        # generate output key form the bibtex key
-        bibkey = entry[1]
-        entryid = entry[2]
-        if keytable[bibkey] == 1:
-            outkey = bibkey
-        else:
-            outkey = bibkey + chr(97 + counttable[bibkey])
-        counttable[bibkey] += 1
-        
-        # append the entry code to the output
-        file.append('\\section ' + entryid + ' [' + outkey + ']')
-        file.append('<div style="' + divstyle + '">')
-        for line in entry[3:]:
-            file.append(line)
-        file.append('</div>')
-        file.append('')
-
-    return file
-
-
-#
-# return 1 iff abbr is in line but not inside braces or quotes
-# assumes that abbr appears only once on the line (out of braces and quotes)
-#
-def verify_out_of_braces(line, abbr):
-
-    phrase_split = delimiter_rex.split(line)
-
-    abbr_rex = re.compile( '\\b' + abbr + '\\b', re.I)
-
-    open_brace = 0
-    open_quote = 0
-
-    for phrase in phrase_split:
-        if phrase == "{":
-            open_brace = open_brace + 1
-        elif phrase == "}":
-            open_brace = open_brace - 1
-        elif phrase == '"':
-            if open_quote == 1:
-                open_quote = 0
-            else:
-                open_quote = 1
-        elif abbr_rex.search(phrase):
-            if open_brace == 0 and open_quote == 0:
-                return 1
-
-    return 0
-
-
-#
-# a line in the form phrase1 # phrase2 # ... # phrasen
-# is returned as phrase1 phrase2 ... phrasen
-# with the correct punctuation
-# Bug: Doesn't always work with multiple abbreviations plugged in
-#
-def concat_line(line):
-    # only look at part after equals
-    field = field_rex.sub('\g<1>',line)
-    rest = field_rex.sub('\g<2>',line)
-
-    concat_line = field + ' ='
-
-    pound_split = concatsplit_rex.split(rest)
-
-    phrase_count = 0
-    length = len(pound_split)
-
-    for phrase in pound_split:
-        phrase = phrase.strip()
-        if phrase_count != 0:
-            if phrase.startswith('"') or phrase.startswith('{'):
-                phrase = phrase[1:]
-        elif phrase.startswith('"'):
-            phrase = phrase.replace('"','{',1)
-
-        if phrase_count != length-1:
-            if phrase.endswith('"') or phrase.endswith('}'):
-                phrase = phrase[:-1]
-        else:
-            if phrase.endswith('"'):
-                phrase = phrase[:-1]
-                phrase = phrase + "}"
-            elif phrase.endswith('",'):
-                phrase = phrase[:-2]
-                phrase = phrase + "},"
-
-        # if phrase did have \#, add the \# back
-        if phrase.endswith('\\'):
-            phrase = phrase + "#"
-        concat_line = concat_line + ' ' + phrase
-
-        phrase_count = phrase_count + 1
-
-    return concat_line
-
-
-#
-# substitute abbreviations into filecont
-# @param filecont_source - string of data from file
-#
-def bibtex_replace_abbreviations(filecont_source):
-    filecont = filecont_source.splitlines()
-
-    #  These are defined in bibtex, so we'll define them too
-    abbr_list = ['jan','feb','mar','apr','may','jun',
-                 'jul','aug','sep','oct','nov','dec']
-    value_list = ['January','February','March','April',
-                  'May','June','July','August','September',
-                  'October','November','December']
-
-    abbr_rex = []
-    total_abbr_count = 0
-
-    front = '\\b'
-    back = '(,?)\\b'
-
-    for x in abbr_list:
-        abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )
-        total_abbr_count = total_abbr_count + 1
-
-
-    abbrdef_rex = re.compile('\s*@string\s*{\s*('+ valid_name_chars +'*)\s*=(.*)',
-                             re.I)
-
-    comment_rex = re.compile('@comment\s*{',re.I)
-    preamble_rex = re.compile('@preamble\s*{',re.I)
-
-    waiting_for_end_string = 0
-    i = 0
-    filecont2 = ''
-
-    for line in filecont:
-        if line == ' ' or line == '':
-            continue
-
-        if waiting_for_end_string:
-            if re.search('}',line):
-                waiting_for_end_string = 0
-                continue
-
-        if abbrdef_rex.search(line):
-            abbr = abbrdef_rex.sub('\g<1>', line)
-
-            if abbr_list.count(abbr) == 0:
-                val = abbrdef_rex.sub('\g<2>', line)
-                abbr_list.append(abbr)
-                value_list.append(string.strip(val))
-                abbr_rex.append( re.compile( front + abbr_list[total_abbr_count] + back, re.I ) )
-                total_abbr_count = total_abbr_count + 1
-            waiting_for_end_string = 1
-            continue
-
-        if comment_rex.search(line):
-            waiting_for_end_string = 1
-            continue
-
-        if preamble_rex.search(line):
-            waiting_for_end_string = 1
-            continue
-
-
-        # replace subsequent abbreviations with the value
-        abbr_count = 0
-
-        for x in abbr_list:
-
-            if abbr_rex[abbr_count].search(line):
-                if verify_out_of_braces(line,abbr_list[abbr_count]) == 1:
-                    line = abbr_rex[abbr_count].sub( value_list[abbr_count] + '\g<1>', line)
-                # Check for # concatenations
-                if concatsplit_rex.search(line):
-                    line = concat_line(line)
-            abbr_count = abbr_count + 1
-
-
-        filecont2 = filecont2 + line + '\n'
-        i = i+1
-
-
-    # Do one final pass over file
-
-    # make sure that didn't end up with {" or }" after the substitution
-    filecont2 = filecont2.replace('{"','{{')
-    filecont2 = filecont2.replace('"}','}}')
-
-    afterquotevalue_rex = re.compile('"\s*,\s*')
-    afterbrace_rex = re.compile('"\s*}')
-    afterbracevalue_rex = re.compile('(=\s*{[^=]*)},\s*')
-
-    # add new lines to data that changed because of abbreviation substitutions
-    filecont2 = afterquotevalue_rex.sub('",\n', filecont2)
-    filecont2 = afterbrace_rex.sub('"\n}', filecont2)
-    filecont2 = afterbracevalue_rex.sub('\g<1>},\n', filecont2)
-
-    return filecont2
-
-#
-# convert @type( ... ) to @type{ ... }
-#
-def no_outer_parens(filecont):
-
-    # do checking for open parens
-    # will convert to braces
-    paren_split = re.split('([(){}])',filecont)
-
-    open_paren_count = 0
-    open_type = 0
-    look_next = 0
-
-    # rebuild filecont
-    filecont = ''
-
-    at_rex = re.compile('@\w*')
-
-    for phrase in paren_split:
-        if look_next == 1:
-            if phrase == '(':
-                phrase = '{'
-                open_paren_count = open_paren_count + 1
-            else:
-                open_type = 0
-            look_next = 0
-
-        if phrase == '(':
-            open_paren_count = open_paren_count + 1
-
-        elif phrase == ')':
-            open_paren_count = open_paren_count - 1
-            if open_type == 1 and open_paren_count == 0:
-                phrase = '}'
-                open_type = 0
-
-        elif at_rex.search( phrase ):
-            open_type = 1
-            look_next = 1
-
-        filecont = filecont + phrase
-
-    return filecont
-
-
-#
-# make all whitespace into just one space
-# format the bibtex file into a usable form.
-#
-def bibtexwasher(filecont_source):
-
-    space_rex = re.compile('\s+')
-    comment_rex = re.compile('\s*%')
-
-    filecont = []
-
-    # remove trailing and excessive whitespace
-    # ignore comments
-    for line in filecont_source:
-        line = string.strip(line)
-        line = space_rex.sub(' ', line)
-        # ignore comments
-        if not comment_rex.match(line) and line != '':
-            filecont.append(' '+ line)
-
-    filecont = string.join(filecont, '')
-
-    # the file is in one long string
-
-    filecont = no_outer_parens(filecont)
-
-    #
-    # split lines according to preferred syntax scheme
-    #
-    filecont = re.sub('(=\s*{[^=]*)},', '\g<1>},\n', filecont)
-
-    # add new lines after commas that are after values
-    filecont = re.sub('"\s*,', '",\n', filecont)
-    filecont = re.sub('=\s*([\w\d]+)\s*,', '= \g<1>,\n', filecont)
-    filecont = re.sub('(@\w*)\s*({(\s*)[^,\s]*)\s*,',
-                          '\n\n\g<1>\g<2>,\n', filecont)
-
-    # add new lines after }
-    filecont = re.sub('"\s*}','"\n}\n', filecont)
-    filecont = re.sub('}\s*,','},\n', filecont)
-
-
-    filecont = re.sub('@(\w*)', '\n@\g<1>', filecont)
-
-    # character encoding, reserved latex characters
-    filecont = re.sub('{\\\&}', '&', filecont)
-    filecont = re.sub('\\\&', '&', filecont)
-
-    # do checking for open braces to get format correct
-    open_brace_count = 0
-    brace_split = re.split('([{}])',filecont)
-
-    # rebuild filecont
-    filecont = ''
-
-    for phrase in brace_split:
-        if phrase == '{':
-            open_brace_count = open_brace_count + 1
-        elif phrase == '}':
-            open_brace_count = open_brace_count - 1
-            if open_brace_count == 0:
-                filecont = filecont + '\n'
-
-        filecont = filecont + phrase
-
-    filecont2 = bibtex_replace_abbreviations(filecont)
-
-    # gather
-    filecont = filecont2.splitlines()
-    i=0
-    j=0         # count the number of blank lines
-    for line in filecont:
-        # ignore blank lines
-        if line == '' or line == ' ':
-            j = j+1
-            continue
-        filecont[i] = line + '\n'
-        i = i+1
-
-    # get rid of the extra stuff at the end of the array
-    # (The extra stuff are duplicates that are in the array because
-    # blank lines were removed.)
-    length = len( filecont)
-    filecont[length-j:length] = []
-
-    return filecont
-
-
-def filehandler(filepath):
-    try:
-        fd = open(filepath, 'r')
-        filecont_source = fd.readlines()
-        fd.close()
-    except:
-        print 'Could not open file:', filepath
-    washeddata = bibtexwasher(filecont_source)
-    outdata = bibtexdecoder(washeddata)
-    print '/**'
-    print '\page references References'
-    print
-    for line in outdata:
-        print line
-    print '*/'
-
-
-# main program
-
-def main():
-    import sys
-    if sys.argv[1:]:
-        filepath = sys.argv[1]
-    else:
-        print "No input file"
-        sys.exit()
-    filehandler(filepath)
-
-if __name__ == "__main__": main()
-
-
-# end python script
Index: scripts/chg-len.py
===================================================================
--- scripts/chg-len.py	(revision 422)
+++ scripts/chg-len.py	(revision 422)
@@ -0,0 +1,32 @@
+#! /usr/bin/env python
+
+import sys
+
+from mercurial import ui, hg
+from mercurial import util
+
+util.rcpath = lambda : []
+
+if len(sys.argv)>1 and sys.argv[1] in ["-h","--help"]:
+    print """
+This utility just prints the length of the longest path
+in the revision graph from revison 0 to the current one.
+"""
+    exit(0)
+
+u = ui.ui()
+r = hg.repository(u, ".")
+N = r.changectx(".").rev()
+lengths=[0]*(N+1)
+for i in range(N+1):
+    p=r.changectx(i).parents()
+    if p[0]:
+        p0=lengths[p[0].rev()]
+    else:
+        p0=-1
+    if len(p)>1 and p[1]:
+        p1=lengths[p[1].rev()]
+    else:
+        p1=-1
+    lengths[i]=max(p0,p1)+1
+print lengths[N]
Index: scripts/mk-release.sh
===================================================================
--- scripts/mk-release.sh	(revision 564)
+++ scripts/mk-release.sh	(revision 564)
@@ -0,0 +1,35 @@
+#!/bin/bash
+
+set -e
+
+if [ $# = 0 ]; then
+    echo "Usage: $0 release-id"
+    exit 1
+else
+    export LEMON_VERSION=$1
+fi
+
+echo '*****************************************************************'
+echo ' Start making release tarballs for version '${LEMON_VERSION}
+echo '*****************************************************************'
+
+autoreconf -vif
+./configure
+
+make
+make html
+make distcheck
+tar xf lemon-${LEMON_VERSION}.tar.gz
+zip -r lemon-${LEMON_VERSION}.zip lemon-${LEMON_VERSION}
+mv lemon-${LEMON_VERSION}/doc/html lemon-doc-${LEMON_VERSION}
+tar czf lemon-doc-${LEMON_VERSION}.tar.gz lemon-doc-${LEMON_VERSION}
+zip -r lemon-doc-${LEMON_VERSION}.zip lemon-doc-${LEMON_VERSION}
+tar czf lemon-nodoc-${LEMON_VERSION}.tar.gz lemon-${LEMON_VERSION}
+zip -r lemon-nodoc-${LEMON_VERSION}.zip lemon-${LEMON_VERSION}
+hg tag -m 'LEMON '${LEMON_VERSION}' released ('$(hg par --template="{node|short}")' tagged as r'${LEMON_VERSION}')' r${LEMON_VERSION}
+
+rm -rf lemon-${LEMON_VERSION} lemon-doc-${LEMON_VERSION}
+
+echo '*****************************************************************'
+echo '  Release '${LEMON_VERSION}' has been created' 
+echo '*****************************************************************'
Index: scripts/unify-sources.sh
===================================================================
--- scripts/unify-sources.sh	(revision 733)
+++ scripts/unify-sources.sh	(revision 655)
@@ -1,17 +1,3 @@
 #!/bin/bash
-#
-# This file is a part of LEMON, a generic C++ optimization library.
-#
-# Copyright (C) 2003-2009
-# Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-# (Egervary Research Group on Combinatorial Optimization, EGRES).
-#
-# Permission to use, modify and distribute this software is granted
-# provided that this copyright notice appears in all copies. For
-# precise terms see the accompanying LICENSE file.
-#
-# This software is provided "AS IS" with no warranty of any kind,
-# express or implied, and with no claim as to its suitability for any
-# purpose.
 
 YEAR=`date +%Y`
Index: ripts/valgrind-wrapper.sh
===================================================================
--- scripts/valgrind-wrapper.sh	(revision 793)
+++ 	(revision )
@@ -1,22 +1,0 @@
-#!/bin/sh
-
-# Run in valgrind, with leak checking enabled
-
-valgrind -q --leak-check=full "$@" 2> .valgrind-log
-
-# Save the test result
-
-result="$?"
-
-# Valgrind should generate no error messages
-
-log_contents="`cat .valgrind-log`"
-
-if [ "$log_contents" != "" ]; then
-        cat .valgrind-log >&2
-        result=1
-fi
-
-rm -f .valgrind-log
-
-exit $result
Index: test/CMakeLists.txt
===================================================================
--- test/CMakeLists.txt	(revision 974)
+++ test/CMakeLists.txt	(revision 972)
@@ -14,5 +14,4 @@
 SET(TESTS
   adaptors_test
-  bellman_ford_test
   bfs_test
   circulation_test
@@ -26,5 +25,4 @@
   error_test
   euler_test
-  fractional_matching_test
   gomory_hu_test
   graph_copy_test
@@ -37,12 +35,7 @@
   maps_test
   matching_test
-  max_cardinality_search_test
-  max_clique_test
   min_cost_arborescence_test
   min_cost_flow_test
-  min_mean_cycle_test
-  nagamochi_ibaraki_test
   path_test
-  planarity_test
   preflow_test
   radix_sort_test
Index: test/Makefile.am
===================================================================
--- test/Makefile.am	(revision 959)
+++ test/Makefile.am	(revision 959)
@@ -0,0 +1,89 @@
+EXTRA_DIST += \
+	test/CMakeLists.txt
+
+noinst_HEADERS += \
+	test/graph_test.h \
+	test/test_tools.h
+
+check_PROGRAMS += \
+	test/adaptors_test \
+	test/bfs_test \
+	test/circulation_test \
+	test/connectivity_test \
+	test/counter_test \
+	test/dfs_test \
+	test/digraph_test \
+	test/dijkstra_test \
+	test/dim_test \
+	test/edge_set_test \
+	test/error_test \
+	test/euler_test \
+	test/gomory_hu_test \
+	test/graph_copy_test \
+	test/graph_test \
+	test/graph_utils_test \
+	test/hao_orlin_test \
+	test/heap_test \
+	test/kruskal_test \
+	test/lgf_test \
+	test/maps_test \
+	test/matching_test \
+	test/min_cost_arborescence_test \
+	test/min_cost_flow_test \
+	test/path_test \
+	test/preflow_test \
+	test/radix_sort_test \
+	test/random_test \
+	test/suurballe_test \
+	test/test_tools_fail \
+	test/test_tools_pass \
+	test/time_measure_test \
+	test/unionfind_test
+
+test_test_tools_pass_DEPENDENCIES = demo
+
+if HAVE_LP
+check_PROGRAMS += test/lp_test
+endif HAVE_LP
+if HAVE_MIP
+check_PROGRAMS += test/mip_test
+endif HAVE_MIP
+
+TESTS += $(check_PROGRAMS)
+XFAIL_TESTS += test/test_tools_fail$(EXEEXT)
+
+test_adaptors_test_SOURCES = test/adaptors_test.cc
+test_bfs_test_SOURCES = test/bfs_test.cc
+test_circulation_test_SOURCES = test/circulation_test.cc
+test_counter_test_SOURCES = test/counter_test.cc
+test_connectivity_test_SOURCES = test/connectivity_test.cc
+test_dfs_test_SOURCES = test/dfs_test.cc
+test_digraph_test_SOURCES = test/digraph_test.cc
+test_dijkstra_test_SOURCES = test/dijkstra_test.cc
+test_dim_test_SOURCES = test/dim_test.cc
+test_edge_set_test_SOURCES = test/edge_set_test.cc
+test_error_test_SOURCES = test/error_test.cc
+test_euler_test_SOURCES = test/euler_test.cc
+test_gomory_hu_test_SOURCES = test/gomory_hu_test.cc
+test_graph_copy_test_SOURCES = test/graph_copy_test.cc
+test_graph_test_SOURCES = test/graph_test.cc
+test_graph_utils_test_SOURCES = test/graph_utils_test.cc
+test_heap_test_SOURCES = test/heap_test.cc
+test_kruskal_test_SOURCES = test/kruskal_test.cc
+test_hao_orlin_test_SOURCES = test/hao_orlin_test.cc
+test_lgf_test_SOURCES = test/lgf_test.cc
+test_lp_test_SOURCES = test/lp_test.cc
+test_maps_test_SOURCES = test/maps_test.cc
+test_mip_test_SOURCES = test/mip_test.cc
+test_matching_test_SOURCES = test/matching_test.cc
+test_min_cost_arborescence_test_SOURCES = test/min_cost_arborescence_test.cc
+test_min_cost_flow_test_SOURCES = test/min_cost_flow_test.cc
+test_path_test_SOURCES = test/path_test.cc
+test_preflow_test_SOURCES = test/preflow_test.cc
+test_radix_sort_test_SOURCES = test/radix_sort_test.cc
+test_suurballe_test_SOURCES = test/suurballe_test.cc
+test_random_test_SOURCES = test/random_test.cc
+test_test_tools_fail_SOURCES = test/test_tools_fail.cc
+test_test_tools_pass_SOURCES = test/test_tools_pass.cc
+test_time_measure_test_SOURCES = test/time_measure_test.cc
+test_unionfind_test_SOURCES = test/unionfind_test.cc
Index: test/adaptors_test.cc
===================================================================
--- test/adaptors_test.cc	(revision 515)
+++ test/adaptors_test.cc	(revision 465)
@@ -1372,18 +1372,26 @@
 
   GridGraph::EdgeMap<bool> dir_map(graph);
-  dir_map[graph.right(n1)] = graph.u(graph.right(n1)) != n1;
-  dir_map[graph.up(n1)] = graph.u(graph.up(n1)) == n1;
-  dir_map[graph.left(n4)] = graph.u(graph.left(n4)) == n4;
-  dir_map[graph.down(n4)] = graph.u(graph.down(n4)) == n4;
+  dir_map[graph.right(n1)] = graph.u(graph.right(n1)) == n1;
+  dir_map[graph.up(n1)] = graph.u(graph.up(n1)) != n1;
+  dir_map[graph.left(n4)] = graph.u(graph.left(n4)) != n4;
+  dir_map[graph.down(n4)] = graph.u(graph.down(n4)) != n4;
 
   // Apply several adaptors on the grid graph
-  typedef SplitNodes<Orienter< const GridGraph, GridGraph::EdgeMap<bool> > >
-    SplitGridGraph;
+  typedef SplitNodes< ReverseDigraph< const Orienter<
+            const GridGraph, GridGraph::EdgeMap<bool> > > >
+    RevSplitGridGraph;
+  typedef ReverseDigraph<const RevSplitGridGraph> SplitGridGraph;
   typedef Undirector<const SplitGridGraph> USplitGridGraph;
+  typedef Undirector<const USplitGridGraph> UUSplitGridGraph;
+  checkConcept<concepts::Digraph, RevSplitGridGraph>();
   checkConcept<concepts::Digraph, SplitGridGraph>();
   checkConcept<concepts::Graph, USplitGridGraph>();
-
-  SplitGridGraph adaptor = splitNodes(orienter(graph, dir_map));
+  checkConcept<concepts::Graph, UUSplitGridGraph>();
+
+  RevSplitGridGraph rev_adaptor =
+    splitNodes(reverseDigraph(orienter(graph, dir_map)));
+  SplitGridGraph adaptor = reverseDigraph(rev_adaptor);
   USplitGridGraph uadaptor = undirector(adaptor);
+  UUSplitGridGraph uuadaptor = undirector(uadaptor);
 
   // Check adaptor
@@ -1392,21 +1400,21 @@
   checkGraphConArcList(adaptor, 8);
 
-  checkGraphOutArcList(adaptor, adaptor.inNode(n1), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n1), 1);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n2), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n2), 0);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n3), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n3), 1);
-  checkGraphOutArcList(adaptor, adaptor.inNode(n4), 1);
-  checkGraphOutArcList(adaptor, adaptor.outNode(n4), 2);
-
-  checkGraphInArcList(adaptor, adaptor.inNode(n1), 1);
-  checkGraphInArcList(adaptor, adaptor.outNode(n1), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n2), 2);
-  checkGraphInArcList(adaptor, adaptor.outNode(n2), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n3), 1);
-  checkGraphInArcList(adaptor, adaptor.outNode(n3), 1);
-  checkGraphInArcList(adaptor, adaptor.inNode(n4), 0);
-  checkGraphInArcList(adaptor, adaptor.outNode(n4), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n1), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n1), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n2), 2);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n2), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n3), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n3), 1);
+  checkGraphOutArcList(adaptor, rev_adaptor.inNode(n4), 0);
+  checkGraphOutArcList(adaptor, rev_adaptor.outNode(n4), 1);
+
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n1), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n1), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n2), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n2), 0);
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n3), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n3), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.inNode(n4), 1);
+  checkGraphInArcList(adaptor, rev_adaptor.outNode(n4), 2);
 
   checkNodeIds(adaptor);
@@ -1431,12 +1439,27 @@
   checkGraphArcMap(uadaptor);
 
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n1), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n1), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n2), 3);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n2), 1);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n3), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n3), 2);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.inNode(n4), 1);
-  checkGraphIncEdgeArcLists(uadaptor, adaptor.outNode(n4), 3);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n1), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n1), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n2), 3);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n2), 1);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n3), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n3), 2);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.inNode(n4), 1);
+  checkGraphIncEdgeArcLists(uadaptor, rev_adaptor.outNode(n4), 3);
+
+  // Check uuadaptor
+  checkGraphNodeList(uuadaptor, 8);
+  checkGraphEdgeList(uuadaptor, 16);
+  checkGraphArcList(uuadaptor, 32);
+  checkGraphConEdgeList(uuadaptor, 16);
+  checkGraphConArcList(uuadaptor, 32);
+
+  checkNodeIds(uuadaptor);
+  checkEdgeIds(uuadaptor);
+  checkArcIds(uuadaptor);
+
+  checkGraphNodeMap(uuadaptor);
+  checkGraphEdgeMap(uuadaptor);
+  checkGraphArcMap(uuadaptor);
 }
 
Index: st/bellman_ford_test.cc
===================================================================
--- test/bellman_ford_test.cc	(revision 880)
+++ 	(revision )
@@ -1,285 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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.
- *
- */
-
-#include <lemon/concepts/digraph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/list_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/bellman_ford.h>
-#include <lemon/path.h>
-
-#include "graph_test.h"
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "@arcs\n"
-  "    length\n"
-  "0 1 3\n"
-  "1 2 -3\n"
-  "1 2 -5\n"
-  "1 3 -2\n"
-  "0 2 -1\n"
-  "1 2 -4\n"
-  "0 3 2\n"
-  "4 2 -5\n"
-  "2 3 1\n"
-  "@attributes\n"
-  "source 0\n"
-  "target 3\n";
-
-
-void checkBellmanFordCompile()
-{
-  typedef int Value;
-  typedef concepts::Digraph Digraph;
-  typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
-  typedef BellmanFord<Digraph, LengthMap> BF;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-
-  Digraph gr;
-  Node s, t, n;
-  Arc e;
-  Value l;
-  int k=3;
-  bool b;
-  BF::DistMap d(gr);
-  BF::PredMap p(gr);
-  LengthMap length;
-  concepts::Path<Digraph> pp;
-
-  {
-    BF bf_test(gr,length);
-    const BF& const_bf_test = bf_test;
-
-    bf_test.run(s);
-    bf_test.run(s,k);
-
-    bf_test.init();
-    bf_test.addSource(s);
-    bf_test.addSource(s, 1);
-    b = bf_test.processNextRound();
-    b = bf_test.processNextWeakRound();
-
-    bf_test.start();
-    bf_test.checkedStart();
-    bf_test.limitedStart(k);
-
-    l  = const_bf_test.dist(t);
-    e  = const_bf_test.predArc(t);
-    s  = const_bf_test.predNode(t);
-    b  = const_bf_test.reached(t);
-    d  = const_bf_test.distMap();
-    p  = const_bf_test.predMap();
-    pp = const_bf_test.path(t);
-    pp = const_bf_test.negativeCycle();
-
-    for (BF::ActiveIt it(const_bf_test); it != INVALID; ++it) {}
-  }
-  {
-    BF::SetPredMap<concepts::ReadWriteMap<Node,Arc> >
-      ::SetDistMap<concepts::ReadWriteMap<Node,Value> >
-      ::SetOperationTraits<BellmanFordDefaultOperationTraits<Value> >
-      ::Create bf_test(gr,length);
-
-    LengthMap length_map;
-    concepts::ReadWriteMap<Node,Arc> pred_map;
-    concepts::ReadWriteMap<Node,Value> dist_map;
-
-    bf_test
-      .lengthMap(length_map)
-      .predMap(pred_map)
-      .distMap(dist_map);
-
-    bf_test.run(s);
-    bf_test.run(s,k);
-
-    bf_test.init();
-    bf_test.addSource(s);
-    bf_test.addSource(s, 1);
-    b = bf_test.processNextRound();
-    b = bf_test.processNextWeakRound();
-
-    bf_test.start();
-    bf_test.checkedStart();
-    bf_test.limitedStart(k);
-
-    l  = bf_test.dist(t);
-    e  = bf_test.predArc(t);
-    s  = bf_test.predNode(t);
-    b  = bf_test.reached(t);
-    pp = bf_test.path(t);
-    pp = bf_test.negativeCycle();
-  }
-}
-
-void checkBellmanFordFunctionCompile()
-{
-  typedef int Value;
-  typedef concepts::Digraph Digraph;
-  typedef Digraph::Arc Arc;
-  typedef Digraph::Node Node;
-  typedef concepts::ReadMap<Digraph::Arc,Value> LengthMap;
-
-  Digraph g;
-  bool b;
-  bellmanFord(g,LengthMap()).run(Node());
-  b = bellmanFord(g,LengthMap()).run(Node(),Node());
-  bellmanFord(g,LengthMap())
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,Value>())
-    .run(Node());
-  b=bellmanFord(g,LengthMap())
-    .predMap(concepts::ReadWriteMap<Node,Arc>())
-    .distMap(concepts::ReadWriteMap<Node,Value>())
-    .path(concepts::Path<Digraph>())
-    .dist(Value())
-    .run(Node(),Node());
-}
-
-
-template <typename Digraph, typename Value>
-void checkBellmanFord() {
-  TEMPLATE_DIGRAPH_TYPEDEFS(Digraph);
-  typedef typename Digraph::template ArcMap<Value> LengthMap;
-
-  Digraph gr;
-  Node s, t;
-  LengthMap length(gr);
-
-  std::istringstream input(test_lgf);
-  digraphReader(gr, input).
-    arcMap("length", length).
-    node("source", s).
-    node("target", t).
-    run();
-
-  BellmanFord<Digraph, LengthMap>
-    bf(gr, length);
-  bf.run(s);
-  Path<Digraph> p = bf.path(t);
-
-  check(bf.reached(t) && bf.dist(t) == -1, "Bellman-Ford found a wrong path.");
-  check(p.length() == 3, "path() found a wrong path.");
-  check(checkPath(gr, p), "path() found a wrong path.");
-  check(pathSource(gr, p) == s, "path() found a wrong path.");
-  check(pathTarget(gr, p) == t, "path() found a wrong path.");
-
-  ListPath<Digraph> path;
-  Value dist;
-  bool reached = bellmanFord(gr,length).path(path).dist(dist).run(s,t);
-
-  check(reached && dist == -1, "Bellman-Ford found a wrong path.");
-  check(path.length() == 3, "path() found a wrong path.");
-  check(checkPath(gr, path), "path() found a wrong path.");
-  check(pathSource(gr, path) == s, "path() found a wrong path.");
-  check(pathTarget(gr, path) == t, "path() found a wrong path.");
-
-  for(ArcIt e(gr); e!=INVALID; ++e) {
-    Node u=gr.source(e);
-    Node v=gr.target(e);
-    check(!bf.reached(u) || (bf.dist(v) - bf.dist(u) <= length[e]),
-          "Wrong output. dist(target)-dist(source)-arc_length=" <<
-          bf.dist(v) - bf.dist(u) - length[e]);
-  }
-
-  for(NodeIt v(gr); v!=INVALID; ++v) {
-    if (bf.reached(v)) {
-      check(v==s || bf.predArc(v)!=INVALID, "Wrong tree.");
-      if (bf.predArc(v)!=INVALID ) {
-        Arc e=bf.predArc(v);
-        Node u=gr.source(e);
-        check(u==bf.predNode(v),"Wrong tree.");
-        check(bf.dist(v) - bf.dist(u) == length[e],
-              "Wrong distance! Difference: " <<
-              bf.dist(v) - bf.dist(u) - length[e]);
-      }
-    }
-  }
-}
-
-void checkBellmanFordNegativeCycle() {
-  DIGRAPH_TYPEDEFS(SmartDigraph);
-
-  SmartDigraph gr;
-  IntArcMap length(gr);
-
-  Node n1 = gr.addNode();
-  Node n2 = gr.addNode();
-  Node n3 = gr.addNode();
-  Node n4 = gr.addNode();
-
-  Arc a1 = gr.addArc(n1, n2);
-  Arc a2 = gr.addArc(n2, n2);
-
-  length[a1] = 2;
-  length[a2] = -1;
-
-  {
-    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
-    bf.run(n1);
-    StaticPath<SmartDigraph> p = bf.negativeCycle();
-    check(p.length() == 1 && p.front() == p.back() && p.front() == a2,
-          "Wrong negative cycle.");
-  }
-
-  length[a2] = 0;
-
-  {
-    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
-    bf.run(n1);
-    check(bf.negativeCycle().empty(),
-          "Negative cycle should not be found.");
-  }
-
-  length[gr.addArc(n1, n3)] = 5;
-  length[gr.addArc(n4, n3)] = 1;
-  length[gr.addArc(n2, n4)] = 2;
-  length[gr.addArc(n3, n2)] = -4;
-
-  {
-    BellmanFord<SmartDigraph, IntArcMap> bf(gr, length);
-    bf.init();
-    bf.addSource(n1);
-    for (int i = 0; i < 4; ++i) {
-      check(bf.negativeCycle().empty(),
-            "Negative cycle should not be found.");
-      bf.processNextRound();
-    }
-    StaticPath<SmartDigraph> p = bf.negativeCycle();
-    check(p.length() == 3, "Wrong negative cycle.");
-    check(length[p.nth(0)] + length[p.nth(1)] + length[p.nth(2)] == -1,
-          "Wrong negative cycle.");
-  }
-}
-
-int main() {
-  checkBellmanFord<ListDigraph, int>();
-  checkBellmanFord<SmartDigraph, double>();
-  checkBellmanFordNegativeCycle();
-  return 0;
-}
Index: test/bfs_test.cc
===================================================================
--- test/bfs_test.cc	(revision 877)
+++ test/bfs_test.cc	(revision 585)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -84,5 +84,5 @@
     b = const_bfs_test.emptyQueue();
     i = const_bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
@@ -105,10 +105,10 @@
       ::SetProcessedMap<concepts::WriteMap<Node,bool> >
       ::Create bfs_test(G);
-
+      
     concepts::ReadWriteMap<Node,Arc> pred_map;
     concepts::ReadWriteMap<Node,int> dist_map;
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     bfs_test
       .predMap(pred_map)
@@ -120,5 +120,5 @@
     bfs_test.run(s,t);
     bfs_test.run();
-
+    
     bfs_test.init();
     bfs_test.addSource(s);
@@ -129,5 +129,5 @@
     b = bfs_test.emptyQueue();
     i = bfs_test.queueSize();
-
+    
     bfs_test.start();
     bfs_test.start(t);
Index: test/circulation_test.cc
===================================================================
--- test/circulation_test.cc	(revision 877)
+++ test/circulation_test.cc	(revision 611)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -82,5 +82,5 @@
   CirculationType circ_test(g, lcap, ucap, supply);
   const CirculationType& const_circ_test = circ_test;
-
+   
   circ_test
     .lowerMap(lcap)
@@ -88,9 +88,4 @@
     .supplyMap(supply)
     .flowMap(flow);
-
-  const CirculationType::Elevator& elev = const_circ_test.elevator();
-  circ_test.elevator(const_cast<CirculationType::Elevator&>(elev));
-  CirculationType::Tolerance tol = const_circ_test.tolerance();
-  circ_test.tolerance(tol);
 
   circ_test.init();
@@ -103,5 +98,5 @@
   b = const_circ_test.barrier(n);
   const_circ_test.barrierMap(bar);
-
+  
   ignore_unused_variable_warning(fm);
 }
Index: test/connectivity_test.cc
===================================================================
--- test/connectivity_test.cc	(revision 877)
+++ test/connectivity_test.cc	(revision 649)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -30,10 +30,10 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Digraph::NodeMap<int> order(d);
-    Graph g(d);
-
+  
+  {
+    Digraph d;
+    Digraph::NodeMap<int> order(d);
+    Graph g(d);
+    
     check(stronglyConnected(d), "The empty digraph is strongly connected");
     check(countStronglyConnectedComponents(d) == 0,
@@ -49,5 +49,5 @@
     check(countBiEdgeConnectedComponents(g) == 0,
           "The empty graph has 0 bi-edge-connected component");
-
+          
     check(dag(d), "The empty digraph is DAG.");
     check(checkedTopologicalSort(d, order), "The empty digraph is DAG.");
@@ -83,5 +83,5 @@
     check(countBiEdgeConnectedComponents(g) == 1,
           "This graph has 1 bi-edge-connected component");
-
+          
     check(dag(d), "This digraph is DAG.");
     check(checkedTopologicalSort(d, order), "This digraph is DAG.");
@@ -102,5 +102,5 @@
     Digraph::NodeMap<int> order(d);
     Graph g(d);
-
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -109,5 +109,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n3);
     d.addArc(n3, n2);
@@ -137,21 +137,21 @@
     check(!parallelFree(g), "This graph is not parallel-free.");
     check(!simpleGraph(g), "This graph is not simple.");
-
+    
     d.addArc(n3, n3);
-
+    
     check(!loopFree(d), "This digraph is not loop-free.");
     check(!loopFree(g), "This graph is not loop-free.");
     check(!simpleGraph(d), "This digraph is not simple.");
-
+    
     d.addArc(n3, n2);
-
+    
     check(!parallelFree(d), "This digraph is not parallel-free.");
   }
-
+  
   {
     Digraph d;
     Digraph::ArcMap<bool> cutarcs(d, false);
     Graph g(d);
-
+    
     Digraph::Node n1 = d.addNode();
     Digraph::Node n2 = d.addNode();
@@ -173,5 +173,5 @@
     d.addArc(n6, n7);
     d.addArc(n7, n6);
-
+   
     check(!stronglyConnected(d), "This digraph is not strongly connected");
     check(countStronglyConnectedComponents(d) == 3,
@@ -236,5 +236,5 @@
     Digraph d;
     Digraph::NodeMap<int> order(d);
-
+    
     Digraph::Node belt = d.addNode();
     Digraph::Node trousers = d.addNode();
@@ -256,5 +256,5 @@
     d.addArc(shirt, necktie);
     d.addArc(necktie, coat);
-
+    
     check(dag(d), "This digraph is DAG.");
     topologicalSort(d, order);
@@ -268,5 +268,5 @@
     ListGraph g;
     ListGraph::NodeMap<bool> map(g);
-
+    
     ListGraph::Node n1 = g.addNode();
     ListGraph::Node n2 = g.addNode();
@@ -284,8 +284,8 @@
     g.addEdge(n4, n7);
     g.addEdge(n5, n7);
-
+   
     check(bipartite(g), "This graph is bipartite");
     check(bipartitePartitions(g, map), "This graph is bipartite");
-
+    
     check(map[n1] == map[n2] && map[n1] == map[n6] && map[n1] == map[n7],
           "Wrong bipartitePartitions()");
Index: test/dfs_test.cc
===================================================================
--- test/dfs_test.cc	(revision 966)
+++ test/dfs_test.cc	(revision 959)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -87,5 +87,5 @@
     b = const_dfs_test.emptyQueue();
     i = const_dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
@@ -113,5 +113,5 @@
     concepts::ReadWriteMap<Node,bool> reached_map;
     concepts::WriteMap<Node,bool> processed_map;
-
+    
     dfs_test
       .predMap(pred_map)
@@ -130,5 +130,5 @@
     b = dfs_test.emptyQueue();
     i = dfs_test.queueSize();
-
+    
     dfs_test.start();
     dfs_test.start(t);
Index: test/digraph_test.cc
===================================================================
--- test/digraph_test.cc	(revision 877)
+++ test/digraph_test.cc	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -20,5 +20,4 @@
 #include <lemon/list_graph.h>
 #include <lemon/smart_graph.h>
-#include <lemon/static_graph.h>
 #include <lemon/full_graph.h>
 
@@ -36,7 +35,4 @@
   checkGraphNodeList(G, 0);
   checkGraphArcList(G, 0);
-
-  G.reserveNode(3);
-  G.reserveArc(4);
 
   Node
@@ -288,12 +284,4 @@
 
   snapshot.restore();
-  snapshot.save(G);
-
-  checkGraphNodeList(G, 4);
-  checkGraphArcList(G, 4);
-
-  G.addArc(G.addNode(), G.addNode());
-
-  snapshot.restore();
 
   checkGraphNodeList(G, 4);
@@ -330,8 +318,4 @@
     checkConcept<ClearableDigraphComponent<>, SmartDigraph>();
   }
-  { // Checking StaticDigraph
-    checkConcept<Digraph, StaticDigraph>();
-    checkConcept<ClearableDigraphComponent<>, StaticDigraph>();
-  }
   { // Checking FullDigraph
     checkConcept<Digraph, FullDigraph>();
@@ -389,120 +373,8 @@
 }
 
-void checkStaticDigraph() {
-  SmartDigraph g;
-  SmartDigraph::NodeMap<StaticDigraph::Node> nref(g);
-  SmartDigraph::ArcMap<StaticDigraph::Arc> aref(g);
-
-  StaticDigraph G;
-
-  checkGraphNodeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  G.build(g, nref, aref);
-
-  checkGraphNodeList(G, 0);
-  checkGraphArcList(G, 0);
-
-  SmartDigraph::Node
-    n1 = g.addNode(),
-    n2 = g.addNode(),
-    n3 = g.addNode();
-
-  G.build(g, nref, aref);
-
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 0);
-
-  SmartDigraph::Arc a1 = g.addArc(n1, n2);
-
-  G.build(g, nref, aref);
-
-  check(G.source(aref[a1]) == nref[n1] && G.target(aref[a1]) == nref[n2],
-        "Wrong arc or wrong references");
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 1);
-
-  checkGraphOutArcList(G, nref[n1], 1);
-  checkGraphOutArcList(G, nref[n2], 0);
-  checkGraphOutArcList(G, nref[n3], 0);
-
-  checkGraphInArcList(G, nref[n1], 0);
-  checkGraphInArcList(G, nref[n2], 1);
-  checkGraphInArcList(G, nref[n3], 0);
-
-  checkGraphConArcList(G, 1);
-
-  SmartDigraph::Arc
-    a2 = g.addArc(n2, n1),
-    a3 = g.addArc(n2, n3),
-    a4 = g.addArc(n2, n3);
-
-  digraphCopy(g, G).nodeRef(nref).run();
-
-  checkGraphNodeList(G, 3);
-  checkGraphArcList(G, 4);
-
-  checkGraphOutArcList(G, nref[n1], 1);
-  checkGraphOutArcList(G, nref[n2], 3);
-  checkGraphOutArcList(G, nref[n3], 0);
-
-  checkGraphInArcList(G, nref[n1], 1);
-  checkGraphInArcList(G, nref[n2], 1);
-  checkGraphInArcList(G, nref[n3], 2);
-
-  checkGraphConArcList(G, 4);
-
-  std::vector<std::pair<int,int> > arcs;
-  arcs.push_back(std::make_pair(0,1));
-  arcs.push_back(std::make_pair(0,2));
-  arcs.push_back(std::make_pair(1,3));
-  arcs.push_back(std::make_pair(1,2));
-  arcs.push_back(std::make_pair(3,0));
-  arcs.push_back(std::make_pair(3,3));
-  arcs.push_back(std::make_pair(4,2));
-  arcs.push_back(std::make_pair(4,3));
-  arcs.push_back(std::make_pair(4,1));
-
-  G.build(6, arcs.begin(), arcs.end());
-
-  checkGraphNodeList(G, 6);
-  checkGraphArcList(G, 9);
-
-  checkGraphOutArcList(G, G.node(0), 2);
-  checkGraphOutArcList(G, G.node(1), 2);
-  checkGraphOutArcList(G, G.node(2), 0);
-  checkGraphOutArcList(G, G.node(3), 2);
-  checkGraphOutArcList(G, G.node(4), 3);
-  checkGraphOutArcList(G, G.node(5), 0);
-
-  checkGraphInArcList(G, G.node(0), 1);
-  checkGraphInArcList(G, G.node(1), 2);
-  checkGraphInArcList(G, G.node(2), 3);
-  checkGraphInArcList(G, G.node(3), 3);
-  checkGraphInArcList(G, G.node(4), 0);
-  checkGraphInArcList(G, G.node(5), 0);
-
-  checkGraphConArcList(G, 9);
-
-  checkNodeIds(G);
-  checkArcIds(G);
-  checkGraphNodeMap(G);
-  checkGraphArcMap(G);
-
-  int n = G.nodeNum();
-  int m = G.arcNum();
-  check(G.index(G.node(n-1)) == n-1, "Wrong index.");
-  check(G.index(G.arc(m-1)) == m-1, "Wrong index.");
-}
-
 void checkFullDigraph(int num) {
   typedef FullDigraph Digraph;
   DIGRAPH_TYPEDEFS(Digraph);
-
   Digraph G(num);
-  check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
-
-  G.resize(num);
-  check(G.nodeNum() == num && G.arcNum() == num * num, "Wrong size");
 
   checkGraphNodeList(G, num);
@@ -548,7 +420,4 @@
     checkDigraphValidity<SmartDigraph>();
   }
-  { // Checking StaticDigraph
-    checkStaticDigraph();
-  }
   { // Checking FullDigraph
     checkFullDigraph(8);
Index: test/dijkstra_test.cc
===================================================================
--- test/dijkstra_test.cc	(revision 877)
+++ test/dijkstra_test.cc	(revision 585)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,5 +86,5 @@
     b = const_dijkstra_test.emptyQueue();
     i = const_dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
@@ -110,5 +110,5 @@
       ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
       ::SetStandardHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> > >
-      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >,
+      ::SetHeap<BinHeap<VType, concepts::ReadWriteMap<Node,int> >, 
                 concepts::ReadWriteMap<Node,int> >
       ::Create dijkstra_test(G,length);
@@ -120,5 +120,5 @@
     concepts::ReadWriteMap<Node,int> heap_cross_ref;
     BinHeap<VType, concepts::ReadWriteMap<Node,int> > heap(heap_cross_ref);
-
+    
     dijkstra_test
       .lengthMap(length_map)
@@ -137,5 +137,5 @@
     b = dijkstra_test.emptyQueue();
     i = dijkstra_test.queueSize();
-
+    
     dijkstra_test.start();
     dijkstra_test.start(t);
Index: test/edge_set_test.cc
===================================================================
--- test/edge_set_test.cc	(revision 877)
+++ test/edge_set_test.cc	(revision 488)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
Index: test/euler_test.cc
===================================================================
--- test/euler_test.cc	(revision 877)
+++ test/euler_test.cc	(revision 592)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -86,9 +86,9 @@
   typedef ListDigraph Digraph;
   typedef Undirector<Digraph> Graph;
-
-  {
-    Digraph d;
-    Graph g(d);
-
+  
+  {
+    Digraph d;
+    Graph g(d);
+    
     checkDiEulerIt(d);
     checkDiEulerIt(g);
@@ -129,5 +129,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n1);
@@ -154,5 +154,5 @@
     Digraph::Node n5 = d.addNode();
     Digraph::Node n6 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n4);
@@ -190,5 +190,5 @@
     Digraph::Node n4 = d.addNode();
     Digraph::Node n5 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n3);
@@ -212,5 +212,5 @@
     Digraph::Node n2 = d.addNode();
     Digraph::Node n3 = d.addNode();
-
+    
     d.addArc(n1, n2);
     d.addArc(n2, n3);
Index: st/fractional_matching_test.cc
===================================================================
--- test/fractional_matching_test.cc	(revision 877)
+++ 	(revision )
@@ -1,525 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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.
- *
- */
-
-#include <iostream>
-#include <sstream>
-#include <vector>
-#include <queue>
-#include <cstdlib>
-
-#include <lemon/fractional_matching.h>
-#include <lemon/smart_graph.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/math.h>
-
-#include "test_tools.h"
-
-using namespace std;
-using namespace lemon;
-
-GRAPH_TYPEDEFS(SmartGraph);
-
-
-const int lgfn = 4;
-const std::string lgf[lgfn] = {
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "7 4  0      984\n"
-  "0 7  1      73\n"
-  "7 1  2      204\n"
-  "2 3  3      583\n"
-  "2 7  4      565\n"
-  "2 1  5      582\n"
-  "0 4  6      551\n"
-  "2 5  7      385\n"
-  "1 5  8      561\n"
-  "5 3  9      484\n"
-  "7 5  10     904\n"
-  "3 6  11     47\n"
-  "7 6  12     888\n"
-  "3 0  13     747\n"
-  "6 1  14     310\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "2 5  0      710\n"
-  "0 5  1      241\n"
-  "2 4  2      856\n"
-  "2 6  3      762\n"
-  "4 1  4      747\n"
-  "6 1  5      962\n"
-  "4 7  6      723\n"
-  "1 7  7      661\n"
-  "2 3  8      376\n"
-  "1 0  9      416\n"
-  "6 7  10     391\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@edges\n"
-  "     label  weight\n"
-  "6 2  0      553\n"
-  "0 7  1      653\n"
-  "6 3  2      22\n"
-  "4 7  3      846\n"
-  "7 2  4      981\n"
-  "7 6  5      250\n"
-  "5 2  6      539\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "@edges\n"
-  "     label  weight\n"
-  "0 0  0      100\n"
-};
-
-void checkMaxFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-
-  Graph g;
-  Node n;
-  Edge e;
-
-  MaxFractionalMatching<Graph> mat_test(g);
-  const MaxFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.start(true);
-  mat_test.startPerfect();
-  mat_test.startPerfect(true);
-  mat_test.run();
-  mat_test.run(true);
-  mat_test.runPerfect();
-  mat_test.runPerfect(true);
-
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.barrier(n);
-}
-
-void checkMaxWeightedFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedFractionalMatching<Graph> mat_test(g, w);
-  const MaxWeightedFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-
-  const_mat_test.matchingWeight();
-  const_mat_test.matchingSize();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxWeightedFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-}
-
-void checkMaxWeightedPerfectFractionalMatchingCompile()
-{
-  typedef concepts::Graph Graph;
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef Graph::EdgeMap<int> WeightMap;
-
-  Graph g;
-  Node n;
-  Edge e;
-  WeightMap w(g);
-
-  MaxWeightedPerfectFractionalMatching<Graph> mat_test(g, w);
-  const MaxWeightedPerfectFractionalMatching<Graph>&
-    const_mat_test = mat_test;
-
-  mat_test.init();
-  mat_test.start();
-  mat_test.run();
-
-  const_mat_test.matchingWeight();
-  const_mat_test.matching(e);
-  const_mat_test.matching(n);
-  const MaxWeightedPerfectFractionalMatching<Graph>::MatchingMap& mmap =
-    const_mat_test.matchingMap();
-  e = mmap[n];
-
-  const_mat_test.dualValue();
-  const_mat_test.nodeValue(n);
-}
-
-void checkFractionalMatching(const SmartGraph& graph,
-                             const MaxFractionalMatching<SmartGraph>& mfm,
-                             bool allow_loops = true) {
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    if (mfm.matching(n) != INVALID) {
-      check(indeg == 1, "Invalid matching");
-      ++pv;
-    } else {
-      check(indeg == 0, "Invalid matching");
-    }
-  }
-  check(pv == mfm.matchingSize(), "Wrong matching size");
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
-          mfm.matching(e), "Invalid matching");
-  }
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  int anum = 0, bnum = 0;
-  SmartGraph::NodeMap<bool> neighbours(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (!mfm.barrier(n)) continue;
-    ++anum;
-    for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) {
-      Node u = graph.source(a);
-      if (!allow_loops && u == n) continue;
-      if (!neighbours[u]) {
-        neighbours[u] = true;
-        ++bnum;
-      }
-    }
-  }
-  check(anum - bnum + mfm.matchingSize() == countNodes(graph),
-        "Wrong barrier");
-}
-
-void checkPerfectFractionalMatching(const SmartGraph& graph,
-                             const MaxFractionalMatching<SmartGraph>& mfm,
-                             bool perfect, bool allow_loops = true) {
-  if (perfect) {
-    for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-      int indeg = 0;
-      for (InArcIt a(graph, n); a != INVALID; ++a) {
-        if (mfm.matching(graph.source(a)) == a) {
-          ++indeg;
-        }
-      }
-      check(mfm.matching(n) != INVALID, "Invalid matching");
-      check(indeg == 1, "Invalid matching");
-    }
-    for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-      check((e == mfm.matching(graph.u(e)) ? 1 : 0) +
-            (e == mfm.matching(graph.v(e)) ? 1 : 0) ==
-            mfm.matching(e), "Invalid matching");
-    }
-  } else {
-    int anum = 0, bnum = 0;
-    SmartGraph::NodeMap<bool> neighbours(graph, false);
-    for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-      if (!mfm.barrier(n)) continue;
-      ++anum;
-      for (SmartGraph::InArcIt a(graph, n); a != INVALID; ++a) {
-        Node u = graph.source(a);
-        if (!allow_loops && u == n) continue;
-        if (!neighbours[u]) {
-          neighbours[u] = true;
-          ++bnum;
-        }
-      }
-    }
-    check(anum - bnum > 0, "Wrong barrier");
-  }
-}
-
-void checkWeightedFractionalMatching(const SmartGraph& graph,
-                   const SmartGraph::EdgeMap<int>& weight,
-                   const MaxWeightedFractionalMatching<SmartGraph>& mwfm,
-                   bool allow_loops = true) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e) && !allow_loops) continue;
-    int rw = mwfm.nodeValue(graph.u(e)) + mwfm.nodeValue(graph.v(e))
-      - weight[e] * mwfm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwfm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mwfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    check(indeg <= 1, "Invalid matching");
-    if (mwfm.matching(n) != INVALID) {
-      check(mwfm.nodeValue(n) >= 0, "Invalid node value");
-      check(indeg == 1, "Invalid matching");
-      pv += weight[mwfm.matching(n)];
-      SmartGraph::Node o = graph.target(mwfm.matching(n));
-    } else {
-      check(mwfm.nodeValue(n) == 0, "Invalid matching");
-      check(indeg == 0, "Invalid matching");
-    }
-  }
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mwfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwfm.matching(graph.v(e)) ? 1 : 0) ==
-          mwfm.matching(e), "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwfm.nodeValue(n);
-  }
-
-  check(pv * mwfm.dualScale == dv * 2, "Wrong duality");
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mwfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mwfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mwfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  return;
-}
-
-void checkWeightedPerfectFractionalMatching(const SmartGraph& graph,
-                const SmartGraph::EdgeMap<int>& weight,
-                const MaxWeightedPerfectFractionalMatching<SmartGraph>& mwpfm,
-                bool allow_loops = true) {
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (graph.u(e) == graph.v(e) && !allow_loops) continue;
-    int rw = mwpfm.nodeValue(graph.u(e)) + mwpfm.nodeValue(graph.v(e))
-      - weight[e] * mwpfm.dualScale;
-
-    check(rw >= 0, "Negative reduced weight");
-    check(rw == 0 || !mwpfm.matching(e),
-          "Non-zero reduced weight on matching edge");
-  }
-
-  int pv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    int indeg = 0;
-    for (InArcIt a(graph, n); a != INVALID; ++a) {
-      if (mwpfm.matching(graph.source(a)) == a) {
-        ++indeg;
-      }
-    }
-    check(mwpfm.matching(n) != INVALID, "Invalid perfect matching");
-    check(indeg == 1, "Invalid perfect matching");
-    pv += weight[mwpfm.matching(n)];
-    SmartGraph::Node o = graph.target(mwpfm.matching(n));
-  }
-
-  for (SmartGraph::EdgeIt e(graph); e != INVALID; ++e) {
-    check((e == mwpfm.matching(graph.u(e)) ? 1 : 0) +
-          (e == mwpfm.matching(graph.v(e)) ? 1 : 0) ==
-          mwpfm.matching(e), "Invalid matching");
-  }
-
-  int dv = 0;
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    dv += mwpfm.nodeValue(n);
-  }
-
-  check(pv * mwpfm.dualScale == dv * 2, "Wrong duality");
-
-  SmartGraph::NodeMap<bool> processed(graph, false);
-  for (SmartGraph::NodeIt n(graph); n != INVALID; ++n) {
-    if (processed[n]) continue;
-    processed[n] = true;
-    if (mwpfm.matching(n) == INVALID) continue;
-    int num = 1;
-    Node v = graph.target(mwpfm.matching(n));
-    while (v != n) {
-      processed[v] = true;
-      ++num;
-      v = graph.target(mwpfm.matching(v));
-    }
-    check(num == 2 || num % 2 == 1, "Wrong cycle size");
-    check(allow_loops || num != 1, "Wrong cycle size");
-  }
-
-  return;
-}
-
-
-int main() {
-
-  for (int i = 0; i < lgfn; ++i) {
-    SmartGraph graph;
-    SmartGraph::EdgeMap<int> weight(graph);
-
-    istringstream lgfs(lgf[i]);
-    graphReader(graph, lgfs).
-      edgeMap("weight", weight).run();
-
-    bool perfect_with_loops;
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, true);
-      mfm.run();
-      checkFractionalMatching(graph, mfm, true);
-      perfect_with_loops = mfm.matchingSize() == countNodes(graph);
-    }
-
-    bool perfect_without_loops;
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, false);
-      mfm.run();
-      checkFractionalMatching(graph, mfm, false);
-      perfect_without_loops = mfm.matchingSize() == countNodes(graph);
-    }
-
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, true);
-      bool result = mfm.runPerfect();
-      checkPerfectFractionalMatching(graph, mfm, result, true);
-      check(result == perfect_with_loops, "Wrong perfect matching");
-    }
-
-    {
-      MaxFractionalMatching<SmartGraph> mfm(graph, false);
-      bool result = mfm.runPerfect();
-      checkPerfectFractionalMatching(graph, mfm, result, false);
-      check(result == perfect_without_loops, "Wrong perfect matching");
-    }
-
-    {
-      MaxWeightedFractionalMatching<SmartGraph> mwfm(graph, weight, true);
-      mwfm.run();
-      checkWeightedFractionalMatching(graph, weight, mwfm, true);
-    }
-
-    {
-      MaxWeightedFractionalMatching<SmartGraph> mwfm(graph, weight, false);
-      mwfm.run();
-      checkWeightedFractionalMatching(graph, weight, mwfm, false);
-    }
-
-    {
-      MaxWeightedPerfectFractionalMatching<SmartGraph> mwpfm(graph, weight,
-                                                             true);
-      bool perfect = mwpfm.run();
-      check(perfect == (mwpfm.matchingSize() == countNodes(graph)),
-            "Perfect matching found");
-      check(perfect == perfect_with_loops, "Wrong perfect matching");
-
-      if (perfect) {
-        checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, true);
-      }
-    }
-
-    {
-      MaxWeightedPerfectFractionalMatching<SmartGraph> mwpfm(graph, weight,
-                                                             false);
-      bool perfect = mwpfm.run();
-      check(perfect == (mwpfm.matchingSize() == countNodes(graph)),
-            "Perfect matching found");
-      check(perfect == perfect_without_loops, "Wrong perfect matching");
-
-      if (perfect) {
-        checkWeightedPerfectFractionalMatching(graph, weight, mwpfm, false);
-      }
-    }
-
-  }
-
-  return 0;
-}
Index: test/gomory_hu_test.cc
===================================================================
--- test/gomory_hu_test.cc	(revision 877)
+++ test/gomory_hu_test.cc	(revision 596)
@@ -1,20 +1,2 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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.
- *
- */
-
 #include <iostream>
 
@@ -52,5 +34,5 @@
   "source 0\n"
   "target 3\n";
-
+  
 void checkGomoryHuCompile()
 {
@@ -88,5 +70,5 @@
 
 int cutValue(const Graph& graph, const BoolNodeMap& cut,
-             const IntEdgeMap& capacity) {
+	     const IntEdgeMap& capacity) {
 
   int sum = 0;
@@ -126,5 +108,5 @@
       int sum=0;
       for(GomoryHu<Graph>::MinCutEdgeIt a(ght, u, v);a!=INVALID;++a)
-        sum+=capacity[a];
+        sum+=capacity[a]; 
       check(sum == ght.minCutValue(u, v), "Problem with MinCutEdgeIt");
 
@@ -137,5 +119,5 @@
     }
   }
-
+  
   return 0;
 }
Index: test/graph_copy_test.cc
===================================================================
--- test/graph_copy_test.cc	(revision 894)
+++ test/graph_copy_test.cc	(revision 893)
@@ -19,5 +19,4 @@
 #include <lemon/smart_graph.h>
 #include <lemon/list_graph.h>
-#include <lemon/static_graph.h>
 #include <lemon/lgf_reader.h>
 #include <lemon/error.h>
@@ -28,5 +27,4 @@
 using namespace lemon;
 
-template <typename GR>
 void digraph_copy_test() {
   const int nn = 10;
@@ -54,17 +52,17 @@
     }
   }
-  
+
   // Test digraph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::Node tn;
-  typename GR::Arc ta;
-
-  SmartDigraph::NodeMap<typename GR::Node> nr(from);
-  SmartDigraph::ArcMap<typename GR::Arc> er(from);
-
-  typename GR::template NodeMap<SmartDigraph::Node> ncr(to);
-  typename GR::template ArcMap<SmartDigraph::Arc> ecr(to);
+  ListDigraph to;
+  ListDigraph::NodeMap<int> tnm(to);
+  ListDigraph::ArcMap<int> tam(to);
+  ListDigraph::Node tn;
+  ListDigraph::Arc ta;
+
+  SmartDigraph::NodeMap<ListDigraph::Node> nr(from);
+  SmartDigraph::ArcMap<ListDigraph::Arc> er(from);
+
+  ListDigraph::NodeMap<SmartDigraph::Node> ncr(to);
+  ListDigraph::ArcMap<SmartDigraph::Arc> ecr(to);
 
   digraphCopy(from, to).
@@ -89,9 +87,9 @@
   }
 
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
+  for (ListDigraph::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
   }
 
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
+  for (ListDigraph::ArcIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
   }
@@ -106,5 +104,4 @@
 }
 
-template <typename GR>
 void graph_copy_test() {
   const int nn = 10;
@@ -139,19 +136,19 @@
 
   // Test graph copy
-  GR to;
-  typename GR::template NodeMap<int> tnm(to);
-  typename GR::template ArcMap<int> tam(to);
-  typename GR::template EdgeMap<int> tem(to);
-  typename GR::Node tn;
-  typename GR::Arc ta;
-  typename GR::Edge te;
-
-  SmartGraph::NodeMap<typename GR::Node> nr(from);
-  SmartGraph::ArcMap<typename GR::Arc> ar(from);
-  SmartGraph::EdgeMap<typename GR::Edge> er(from);
-
-  typename GR::template NodeMap<SmartGraph::Node> ncr(to);
-  typename GR::template ArcMap<SmartGraph::Arc> acr(to);
-  typename GR::template EdgeMap<SmartGraph::Edge> ecr(to);
+  ListGraph to;
+  ListGraph::NodeMap<int> tnm(to);
+  ListGraph::ArcMap<int> tam(to);
+  ListGraph::EdgeMap<int> tem(to);
+  ListGraph::Node tn;
+  ListGraph::Arc ta;
+  ListGraph::Edge te;
+
+  SmartGraph::NodeMap<ListGraph::Node> nr(from);
+  SmartGraph::ArcMap<ListGraph::Arc> ar(from);
+  SmartGraph::EdgeMap<ListGraph::Edge> er(from);
+
+  ListGraph::NodeMap<SmartGraph::Node> ncr(to);
+  ListGraph::ArcMap<SmartGraph::Arc> acr(to);
+  ListGraph::EdgeMap<SmartGraph::Edge> ecr(to);
 
   graphCopy(from, to).
@@ -188,12 +185,12 @@
   }
 
-  for (typename GR::NodeIt it(to); it != INVALID; ++it) {
+  for (ListGraph::NodeIt it(to); it != INVALID; ++it) {
     check(nr[ncr[it]] == it, "Wrong copy.");
   }
 
-  for (typename GR::ArcIt it(to); it != INVALID; ++it) {
+  for (ListGraph::ArcIt it(to); it != INVALID; ++it) {
     check(ar[acr[it]] == it, "Wrong copy.");
   }
-  for (typename GR::EdgeIt it(to); it != INVALID; ++it) {
+  for (ListGraph::EdgeIt it(to); it != INVALID; ++it) {
     check(er[ecr[it]] == it, "Wrong copy.");
   }
@@ -212,9 +209,6 @@
 
 int main() {
-  digraph_copy_test<SmartDigraph>();
-  digraph_copy_test<ListDigraph>();
-  digraph_copy_test<StaticDigraph>();
-  graph_copy_test<SmartGraph>();
-  graph_copy_test<ListGraph>();
+  digraph_copy_test();
+  graph_copy_test();
 
   return 0;
Index: test/graph_test.cc
===================================================================
--- test/graph_test.cc	(revision 877)
+++ test/graph_test.cc	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -39,7 +39,4 @@
   checkGraphArcList(G, 0);
 
-  G.reserveNode(3);
-  G.reserveEdge(3);
-
   Node
     n1 = G.addNode(),
@@ -260,17 +257,8 @@
 
   snapshot.restore();
-  snapshot.save(G);
 
   checkGraphNodeList(G, 4);
   checkGraphEdgeList(G, 3);
   checkGraphArcList(G, 6);
-
-  G.addEdge(G.addNode(), G.addNode());
-
-  snapshot.restore();
-
-  checkGraphNodeList(G, 4);
-  checkGraphEdgeList(G, 3);
-  checkGraphArcList(G, 6);
 }
 
@@ -280,11 +268,4 @@
 
   Graph G(num);
-  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
-        "Wrong size");
-
-  G.resize(num);
-  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,
-        "Wrong size");
-
   checkGraphNodeList(G, num);
   checkGraphEdgeList(G, num * (num - 1) / 2);
@@ -431,8 +412,4 @@
   check(G.height() == height, "Wrong row number");
 
-  G.resize(width, height);
-  check(G.width() == width, "Wrong column number");
-  check(G.height() == height, "Wrong row number");
-
   for (int i = 0; i < width; ++i) {
     for (int j = 0; j < height; ++j) {
@@ -510,9 +487,4 @@
 
   HypercubeGraph G(dim);
-  check(G.dimension() == dim, "Wrong dimension");
-
-  G.resize(dim);
-  check(G.dimension() == dim, "Wrong dimension");
-
   checkGraphNodeList(G, 1 << dim);
   checkGraphEdgeList(G, dim * (1 << (dim-1)));
Index: test/hao_orlin_test.cc
===================================================================
--- test/hao_orlin_test.cc	(revision 877)
+++ test/hao_orlin_test.cc	(revision 597)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -84,5 +84,5 @@
 
 template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value
+typename CapMap::Value 
   cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
 {
@@ -111,5 +111,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
@@ -127,17 +127,17 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 1, "Wrong cut value");
     check(ho.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
   }
-
+  
   typedef Undirector<SmartDigraph> UGraph;
   UGraph ugraph(graph);
-
+  
   {
     HaoOrlin<UGraph, SmartDigraph::ArcMap<int> > ho(ugraph, cap1);
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 2, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap1, cut), "Wrong cut value");
@@ -147,5 +147,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap2, cut), "Wrong cut value");
@@ -155,5 +155,5 @@
     ho.run();
     ho.minCutMap(cut);
-
+    
     check(ho.minCutValue() == 5, "Wrong cut value");
     check(ho.minCutValue() == cutValue(ugraph, cap3, cut), "Wrong cut value");
Index: test/heap_test.cc
===================================================================
--- test/heap_test.cc	(revision 948)
+++ test/heap_test.cc	(revision 681)
@@ -26,4 +26,5 @@
 
 #include <lemon/smart_graph.h>
+
 #include <lemon/lgf_reader.h>
 #include <lemon/dijkstra.h>
@@ -31,10 +32,6 @@
 
 #include <lemon/bin_heap.h>
-#include <lemon/quad_heap.h>
-#include <lemon/dheap.h>
 #include <lemon/fib_heap.h>
-#include <lemon/pairing_heap.h>
 #include <lemon/radix_heap.h>
-#include <lemon/binomial_heap.h>
 #include <lemon/bucket_heap.h>
 
@@ -93,7 +90,9 @@
 void heapSortTest() {
   RangeMap<int> map(test_len, -1);
+
   Heap heap(map);
 
   std::vector<int> v(test_len);
+
   for (int i = 0; i < test_len; ++i) {
     v[i] = test_seq[i];
@@ -102,5 +101,5 @@
   std::sort(v.begin(), v.end());
   for (int i = 0; i < test_len; ++i) {
-    check(v[i] == heap.prio(), "Wrong order in heap sort.");
+    check(v[i] == heap.prio() ,"Wrong order in heap sort.");
     heap.pop();
   }
@@ -114,4 +113,5 @@
 
   std::vector<int> v(test_len);
+
   for (int i = 0; i < test_len; ++i) {
     v[i] = test_seq[i];
@@ -124,8 +124,10 @@
   std::sort(v.begin(), v.end());
   for (int i = 0; i < test_len; ++i) {
-    check(v[i] == heap.prio(), "Wrong order in heap increase test.");
+    check(v[i] == heap.prio() ,"Wrong order in heap increase test.");
     heap.pop();
   }
 }
+
+
 
 template <typename Heap>
@@ -143,5 +145,5 @@
     if (dijkstra.reached(s)) {
       check( dijkstra.dist(t) - dijkstra.dist(s) <= length[a],
-             "Error in shortest path tree.");
+             "Error in a shortest path tree!");
     }
   }
@@ -152,5 +154,5 @@
       Node s = digraph.source(a);
       check( dijkstra.dist(n) - dijkstra.dist(s) == length[a],
-             "Error in shortest path tree.");
+             "Error in a shortest path tree!");
     }
   }
@@ -174,5 +176,4 @@
     run();
 
-  // BinHeap
   {
     typedef BinHeap<Prio, ItemIntMap> IntHeap;
@@ -186,29 +187,4 @@
   }
 
-  // QuadHeap
-  {
-    typedef QuadHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef QuadHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // DHeap
-  {
-    typedef DHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef DHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // FibHeap
   {
     typedef FibHeap<Prio, ItemIntMap> IntHeap;
@@ -222,17 +198,4 @@
   }
 
-  // PairingHeap
-  {
-    typedef PairingHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef PairingHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // RadixHeap
   {
     typedef RadixHeap<ItemIntMap> IntHeap;
@@ -246,17 +209,4 @@
   }
 
-  // BinomialHeap
-  {
-    typedef BinomialHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BinomialHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  // BucketHeap, SimpleBucketHeap
   {
     typedef BucketHeap<ItemIntMap> IntHeap;
@@ -268,40 +218,4 @@
     checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
     dijkstraHeapTest<NodeHeap>(digraph, length, source);
-
-    typedef SimpleBucketHeap<ItemIntMap> SimpleIntHeap;
-    heapSortTest<SimpleIntHeap>();
-  }
-
-  {
-    typedef FibHeap<Prio, ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef FibHeap<Prio, IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  {
-    typedef RadixHeap<ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef RadixHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
-  }
-
-  {
-    typedef BucketHeap<ItemIntMap> IntHeap;
-    checkConcept<Heap<Prio, ItemIntMap>, IntHeap>();
-    heapSortTest<IntHeap>();
-    heapIncreaseTest<IntHeap>();
-
-    typedef BucketHeap<IntNodeMap > NodeHeap;
-    checkConcept<Heap<Prio, IntNodeMap >, NodeHeap>();
-    dijkstraHeapTest<NodeHeap>(digraph, length, source);
   }
 
Index: test/maps_test.cc
===================================================================
--- test/maps_test.cc	(revision 942)
+++ test/maps_test.cc	(revision 684)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,8 +24,4 @@
 #include <lemon/maps.h>
 #include <lemon/list_graph.h>
-#include <lemon/smart_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/dfs.h>
-#include <algorithm>
 
 #include "test_tools.h"
@@ -39,20 +35,7 @@
 
 class C {
-  int _x;
+  int x;
 public:
-  C(int x) : _x(x) {}
-  int get() const { return _x; }
-};
-inline bool operator<(C c1, C c2) { return c1.get() < c2.get(); }
-inline bool operator==(C c1, C c2) { return c1.get() == c2.get(); }
-
-C createC(int x) { return C(x); }
-
-template <typename T>
-class Less {
-  T _t;
-public:
-  Less(T t): _t(t) {}
-  bool operator()(const T& t) const { return t < _t; }
+  C(int _x) : x(_x) {}
 };
 
@@ -70,12 +53,4 @@
 
 int binc(int a, B) { return a+1; }
-
-template <typename T>
-class Sum {
-  T& _sum;
-public:
-  Sum(T& sum) : _sum(sum) {}
-  void operator()(const T& t) { _sum += t; }
-};
 
 typedef ReadMap<A, double> DoubleMap;
@@ -226,6 +201,5 @@
 
     checkConcept<ReadMap<A,B>, MapToFunctor<ReadMap<A,B> > >();
-    MapToFunctor<ReadMap<A,B> > map =
-      MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
+    MapToFunctor<ReadMap<A,B> > map = MapToFunctor<ReadMap<A,B> >(ReadMap<A,B>());
 
     check(functorToMap(&func)[A()] == 3,
@@ -356,8 +330,4 @@
   {
     typedef std::vector<int> vec;
-    checkConcept<WriteMap<int, bool>, LoggerBoolMap<vec::iterator> >();
-    checkConcept<WriteMap<int, bool>,
-                 LoggerBoolMap<std::back_insert_iterator<vec> > >();
-
     vec v1;
     vec v2(10);
@@ -379,208 +349,27 @@
           it != map2.end(); ++it )
       check(v1[i++] == *it, "Something is wrong with LoggerBoolMap");
-
+  }
+  
+  // CrossRefMap
+  {
     typedef ListDigraph Graph;
     DIGRAPH_TYPEDEFS(Graph);
+
+    checkConcept<ReadWriteMap<Node, int>,
+                 CrossRefMap<Graph, Node, int> >();
+    
     Graph gr;
-
+    typedef CrossRefMap<Graph, Node, char> CRMap;
+    typedef CRMap::ValueIterator ValueIt;
+    CRMap map(gr);
+    
     Node n0 = gr.addNode();
     Node n1 = gr.addNode();
     Node n2 = gr.addNode();
-    Node n3 = gr.addNode();
-
-    gr.addArc(n3, n0);
-    gr.addArc(n3, n2);
-    gr.addArc(n0, n2);
-    gr.addArc(n2, n1);
-    gr.addArc(n0, n1);
-
-    {
-      std::vector<Node> v;
-      dfs(gr).processedMap(loggerBoolMap(std::back_inserter(v))).run();
-
-      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
-            "Something is wrong with LoggerBoolMap");
-    }
-    {
-      std::vector<Node> v(countNodes(gr));
-      dfs(gr).processedMap(loggerBoolMap(v.begin())).run();
-
-      check(v.size()==4 && v[0]==n1 && v[1]==n2 && v[2]==n0 && v[3]==n3,
-            "Something is wrong with LoggerBoolMap");
-    }
-  }
-
-  // IdMap, RangeIdMap
-  {
-    typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadMap<Node, int>, IdMap<Graph, Node> >();
-    checkConcept<ReadMap<Arc, int>, IdMap<Graph, Arc> >();
-    checkConcept<ReadMap<Node, int>, RangeIdMap<Graph, Node> >();
-    checkConcept<ReadMap<Arc, int>, RangeIdMap<Graph, Arc> >();
-
-    Graph gr;
-    IdMap<Graph, Node> nmap(gr);
-    IdMap<Graph, Arc> amap(gr);
-    RangeIdMap<Graph, Node> nrmap(gr);
-    RangeIdMap<Graph, Arc> armap(gr);
-
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
-    Arc a0 = gr.addArc(n0, n1);
-    Arc a1 = gr.addArc(n0, n2);
-    Arc a2 = gr.addArc(n2, n1);
-    Arc a3 = gr.addArc(n2, n0);
-
-    check(nmap[n0] == gr.id(n0) && nmap(gr.id(n0)) == n0, "Wrong IdMap");
-    check(nmap[n1] == gr.id(n1) && nmap(gr.id(n1)) == n1, "Wrong IdMap");
-    check(nmap[n2] == gr.id(n2) && nmap(gr.id(n2)) == n2, "Wrong IdMap");
-
-    check(amap[a0] == gr.id(a0) && amap(gr.id(a0)) == a0, "Wrong IdMap");
-    check(amap[a1] == gr.id(a1) && amap(gr.id(a1)) == a1, "Wrong IdMap");
-    check(amap[a2] == gr.id(a2) && amap(gr.id(a2)) == a2, "Wrong IdMap");
-    check(amap[a3] == gr.id(a3) && amap(gr.id(a3)) == a3, "Wrong IdMap");
-
-    check(nmap.inverse()[gr.id(n0)] == n0, "Wrong IdMap::InverseMap");
-    check(amap.inverse()[gr.id(a0)] == a0, "Wrong IdMap::InverseMap");
-
-    check(nrmap.size() == 3 && armap.size() == 4,
-          "Wrong RangeIdMap::size()");
-
-    check(nrmap[n0] == 0 && nrmap(0) == n0, "Wrong RangeIdMap");
-    check(nrmap[n1] == 1 && nrmap(1) == n1, "Wrong RangeIdMap");
-    check(nrmap[n2] == 2 && nrmap(2) == n2, "Wrong RangeIdMap");
-
-    check(armap[a0] == 0 && armap(0) == a0, "Wrong RangeIdMap");
-    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
-    check(armap[a2] == 2 && armap(2) == a2, "Wrong RangeIdMap");
-    check(armap[a3] == 3 && armap(3) == a3, "Wrong RangeIdMap");
-
-    check(nrmap.inverse()[0] == n0, "Wrong RangeIdMap::InverseMap");
-    check(armap.inverse()[0] == a0, "Wrong RangeIdMap::InverseMap");
-
-    gr.erase(n1);
-
-    if (nrmap[n0] == 1) nrmap.swap(n0, n2);
-    nrmap.swap(n2, n0);
-    if (armap[a1] == 1) armap.swap(a1, a3);
-    armap.swap(a3, a1);
-
-    check(nrmap.size() == 2 && armap.size() == 2,
-          "Wrong RangeIdMap::size()");
-
-    check(nrmap[n0] == 1 && nrmap(1) == n0, "Wrong RangeIdMap");
-    check(nrmap[n2] == 0 && nrmap(0) == n2, "Wrong RangeIdMap");
-
-    check(armap[a1] == 1 && armap(1) == a1, "Wrong RangeIdMap");
-    check(armap[a3] == 0 && armap(0) == a3, "Wrong RangeIdMap");
-
-    check(nrmap.inverse()[0] == n2, "Wrong RangeIdMap::InverseMap");
-    check(armap.inverse()[0] == a3, "Wrong RangeIdMap::InverseMap");
-  }
-
-  // SourceMap, TargetMap, ForwardMap, BackwardMap, InDegMap, OutDegMap
-  {
-    typedef ListGraph Graph;
-    GRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadMap<Arc, Node>, SourceMap<Graph> >();
-    checkConcept<ReadMap<Arc, Node>, TargetMap<Graph> >();
-    checkConcept<ReadMap<Edge, Arc>, ForwardMap<Graph> >();
-    checkConcept<ReadMap<Edge, Arc>, BackwardMap<Graph> >();
-    checkConcept<ReadMap<Node, int>, InDegMap<Graph> >();
-    checkConcept<ReadMap<Node, int>, OutDegMap<Graph> >();
-
-    Graph gr;
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
-    gr.addEdge(n0,n1);
-    gr.addEdge(n1,n2);
-    gr.addEdge(n0,n2);
-    gr.addEdge(n2,n1);
-    gr.addEdge(n1,n2);
-    gr.addEdge(n0,n1);
-
-    for (EdgeIt e(gr); e != INVALID; ++e) {
-      check(forwardMap(gr)[e] == gr.direct(e, true), "Wrong ForwardMap");
-      check(backwardMap(gr)[e] == gr.direct(e, false), "Wrong BackwardMap");
-    }
-
-    check(mapCompare(gr,
-          sourceMap(orienter(gr, constMap<Edge, bool>(true))),
-          targetMap(orienter(gr, constMap<Edge, bool>(false)))),
-          "Wrong SourceMap or TargetMap");
-
-    typedef Orienter<Graph, const ConstMap<Edge, bool> > Digraph;
-    Digraph dgr(gr, constMap<Edge, bool>(true));
-    OutDegMap<Digraph> odm(dgr);
-    InDegMap<Digraph> idm(dgr);
-
-    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 1, "Wrong OutDegMap");
-    check(idm[n0] == 0 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
-
-    gr.addEdge(n2, n0);
-
-    check(odm[n0] == 3 && odm[n1] == 2 && odm[n2] == 2, "Wrong OutDegMap");
-    check(idm[n0] == 1 && idm[n1] == 3 && idm[n2] == 3, "Wrong InDegMap");
-  }
-
-  // CrossRefMap
-  {
-    typedef ListDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadWriteMap<Node, int>,
-                 CrossRefMap<Graph, Node, int> >();
-    checkConcept<ReadWriteMap<Node, bool>,
-                 CrossRefMap<Graph, Node, bool> >();
-    checkConcept<ReadWriteMap<Node, double>,
-                 CrossRefMap<Graph, Node, double> >();
-
-    Graph gr;
-    typedef CrossRefMap<Graph, Node, char> CRMap;
-    CRMap map(gr);
-
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
+    
     map.set(n0, 'A');
     map.set(n1, 'B');
     map.set(n2, 'C');
-
-    check(map[n0] == 'A' && map('A') == n0 && map.inverse()['A'] == n0,
-          "Wrong CrossRefMap");
-    check(map[n1] == 'B' && map('B') == n1 && map.inverse()['B'] == n1,
-          "Wrong CrossRefMap");
-    check(map[n2] == 'C' && map('C') == n2 && map.inverse()['C'] == n2,
-          "Wrong CrossRefMap");
-    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
-          "Wrong CrossRefMap::count()");
-
-    CRMap::ValueIt it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
-          it == map.endValue(), "Wrong value iterator");
-
     map.set(n2, 'A');
-
-    check(map[n0] == 'A' && map[n1] == 'B' && map[n2] == 'A',
-          "Wrong CrossRefMap");
-    check(map('A') == n0 && map.inverse()['A'] == n0, "Wrong CrossRefMap");
-    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
-    check(map('C') == INVALID && map.inverse()['C'] == INVALID,
-          "Wrong CrossRefMap");
-    check(map.count('A') == 2 && map.count('B') == 1 && map.count('C') == 0,
-          "Wrong CrossRefMap::count()");
-
-    it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'A' && *it++ == 'B' &&
-          it == map.endValue(), "Wrong value iterator");
-
     map.set(n0, 'C');
 
@@ -590,40 +379,4 @@
     check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
     check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
-    check(map.count('A') == 1 && map.count('B') == 1 && map.count('C') == 1,
-          "Wrong CrossRefMap::count()");
-
-    it = map.beginValue();
-    check(*it++ == 'A' && *it++ == 'B' && *it++ == 'C' &&
-          it == map.endValue(), "Wrong value iterator");
-  }
-
-  // CrossRefMap
-  {
-    typedef SmartDigraph Graph;
-    DIGRAPH_TYPEDEFS(Graph);
-
-    checkConcept<ReadWriteMap<Node, int>,
-                 CrossRefMap<Graph, Node, int> >();
-
-    Graph gr;
-    typedef CrossRefMap<Graph, Node, char> CRMap;
-    typedef CRMap::ValueIterator ValueIt;
-    CRMap map(gr);
-
-    Node n0 = gr.addNode();
-    Node n1 = gr.addNode();
-    Node n2 = gr.addNode();
-
-    map.set(n0, 'A');
-    map.set(n1, 'B');
-    map.set(n2, 'C');
-    map.set(n2, 'A');
-    map.set(n0, 'C');
-
-    check(map[n0] == 'C' && map[n1] == 'B' && map[n2] == 'A',
-          "Wrong CrossRefMap");
-    check(map('A') == n2 && map.inverse()['A'] == n2, "Wrong CrossRefMap");
-    check(map('B') == n1 && map.inverse()['B'] == n1, "Wrong CrossRefMap");
-    check(map('C') == n0 && map.inverse()['C'] == n0, "Wrong CrossRefMap");
 
     ValueIt it = map.beginValue();
@@ -632,372 +385,4 @@
   }
 
-  // Iterable bool map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-
-    typedef IterableBoolMap<SmartGraph, SmartGraph::Node> Ibm;
-    checkConcept<ReferenceMap<Item, bool, bool&, const bool&>, Ibm>();
-
-    const int num = 10;
-    Graph g;
-    Ibm map0(g, true);
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Ibm map1(g, true);
-    int n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)], "Wrong TrueIt");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-    n = 0;
-    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
-        ++n;
-    }
-    check(n == num, "Wrong number");
-    check(Ibm::FalseIt(map1) == INVALID, "Wrong FalseIt");
-    check(Ibm::ItemIt(map1, false) == INVALID, "Wrong ItemIt for false");
-
-    map1[items[5]] = true;
-
-    n = 0;
-    for (Ibm::ItemIt it(map1, true); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong ItemIt for true");
-        ++n;
-    }
-    check(n == num, "Wrong number");
-
-    map1[items[num / 2]] = false;
-    check(map1[items[num / 2]] == false, "Wrong map value");
-
-    n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
-        ++n;
-    }
-    check(n == num - 1, "Wrong number");
-
-    n = 0;
-    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
-        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
-        ++n;
-    }
-    check(n == 1, "Wrong number");
-
-    map1[items[0]] = false;
-    check(map1[items[0]] == false, "Wrong map value");
-
-    map1[items[num - 1]] = false;
-    check(map1[items[num - 1]] == false, "Wrong map value");
-
-    n = 0;
-    for (Ibm::TrueIt it(map1); it != INVALID; ++it) {
-        check(map1[static_cast<Item>(it)], "Wrong TrueIt for true");
-        ++n;
-    }
-    check(n == num - 3, "Wrong number");
-    check(map1.trueNum() == num - 3, "Wrong number");
-
-    n = 0;
-    for (Ibm::FalseIt it(map1); it != INVALID; ++it) {
-        check(!map1[static_cast<Item>(it)], "Wrong FalseIt for true");
-        ++n;
-    }
-    check(n == 3, "Wrong number");
-    check(map1.falseNum() == 3, "Wrong number");
-  }
-
-  // Iterable int map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-    typedef IterableIntMap<SmartGraph, SmartGraph::Node> Iim;
-
-    checkConcept<ReferenceMap<Item, int, int&, const int&>, Iim>();
-
-    const int num = 10;
-    Graph g;
-    Iim map0(g, 0);
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Iim map1(g);
-    check(map1.size() == 0, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      map1[items[i]] = i;
-    }
-    check(map1.size() == num, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      Iim::ItemIt it(map1, i);
-      check(static_cast<Item>(it) == items[i], "Wrong value");
-      ++it;
-      check(static_cast<Item>(it) == INVALID, "Wrong value");
-    }
-
-    for (int i = 0; i < num; ++i) {
-      map1[items[i]] = i % 2;
-    }
-    check(map1.size() == 2, "Wrong size");
-
-    int n = 0;
-    for (Iim::ItemIt it(map1, 0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 0, "Wrong value");
-      ++n;
-    }
-    check(n == (num + 1) / 2, "Wrong number");
-
-    for (Iim::ItemIt it(map1, 1); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 1, "Wrong value");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-  }
-
-  // Iterable value map
-  {
-    typedef SmartGraph Graph;
-    typedef SmartGraph::Node Item;
-    typedef IterableValueMap<SmartGraph, SmartGraph::Node, double> Ivm;
-
-    checkConcept<ReadWriteMap<Item, double>, Ivm>();
-
-    const int num = 10;
-    Graph g;
-    Ivm map0(g, 0.0);
-    std::vector<Item> items;
-    for (int i = 0; i < num; ++i) {
-      items.push_back(g.addNode());
-    }
-
-    Ivm map1(g, 0.0);
-    check(distance(map1.beginValue(), map1.endValue()) == 1, "Wrong size");
-    check(*map1.beginValue() == 0.0, "Wrong value");
-
-    for (int i = 0; i < num; ++i) {
-      map1.set(items[i], static_cast<double>(i));
-    }
-    check(distance(map1.beginValue(), map1.endValue()) == num, "Wrong size");
-
-    for (int i = 0; i < num; ++i) {
-      Ivm::ItemIt it(map1, static_cast<double>(i));
-      check(static_cast<Item>(it) == items[i], "Wrong value");
-      ++it;
-      check(static_cast<Item>(it) == INVALID, "Wrong value");
-    }
-
-    for (Ivm::ValueIt vit = map1.beginValue();
-         vit != map1.endValue(); ++vit) {
-      check(map1[static_cast<Item>(Ivm::ItemIt(map1, *vit))] == *vit,
-            "Wrong ValueIt");
-    }
-
-    for (int i = 0; i < num; ++i) {
-      map1.set(items[i], static_cast<double>(i % 2));
-    }
-    check(distance(map1.beginValue(), map1.endValue()) == 2, "Wrong size");
-
-    int n = 0;
-    for (Ivm::ItemIt it(map1, 0.0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 0.0, "Wrong value");
-      ++n;
-    }
-    check(n == (num + 1) / 2, "Wrong number");
-
-    for (Ivm::ItemIt it(map1, 1.0); it != INVALID; ++it) {
-      check(map1[static_cast<Item>(it)] == 1.0, "Wrong value");
-      ++n;
-    }
-    check(n == num, "Wrong number");
-
-  }
-
-  // Graph map utilities:
-  // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
-  // mapFind(), mapFindIf(), mapCount(), mapCountIf()
-  // mapCopy(), mapCompare(), mapFill()
-  {
-    DIGRAPH_TYPEDEFS(SmartDigraph);
-
-    SmartDigraph g;
-    Node n1 = g.addNode();
-    Node n2 = g.addNode();
-    Node n3 = g.addNode();
-
-    SmartDigraph::NodeMap<int> map1(g);
-    SmartDigraph::ArcMap<char> map2(g);
-    ConstMap<Node, A> cmap1 = A();
-    ConstMap<Arc, C> cmap2 = C(0);
-
-    map1[n1] = 10;
-    map1[n2] = 5;
-    map1[n3] = 12;
-
-    // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
-    check(mapMin(g, map1) == n2, "Wrong mapMin()");
-    check(mapMax(g, map1) == n3, "Wrong mapMax()");
-    check(mapMin(g, map1, std::greater<int>()) == n3, "Wrong mapMin()");
-    check(mapMax(g, map1, std::greater<int>()) == n2, "Wrong mapMax()");
-    check(mapMinValue(g, map1) == 5, "Wrong mapMinValue()");
-    check(mapMaxValue(g, map1) == 12, "Wrong mapMaxValue()");
-
-    check(mapMin(g, map2) == INVALID, "Wrong mapMin()");
-    check(mapMax(g, map2) == INVALID, "Wrong mapMax()");
-
-    check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()");
-    check(mapMax(g, cmap2) == INVALID, "Wrong mapMax()");
-
-    Arc a1 = g.addArc(n1, n2);
-    Arc a2 = g.addArc(n1, n3);
-    Arc a3 = g.addArc(n2, n3);
-    Arc a4 = g.addArc(n3, n1);
-
-    map2[a1] = 'b';
-    map2[a2] = 'a';
-    map2[a3] = 'b';
-    map2[a4] = 'c';
-
-    // mapMin(), mapMax(), mapMinValue(), mapMaxValue()
-    check(mapMin(g, map2) == a2, "Wrong mapMin()");
-    check(mapMax(g, map2) == a4, "Wrong mapMax()");
-    check(mapMin(g, map2, std::greater<int>()) == a4, "Wrong mapMin()");
-    check(mapMax(g, map2, std::greater<int>()) == a2, "Wrong mapMax()");
-    check(mapMinValue(g, map2, std::greater<int>()) == 'c',
-          "Wrong mapMinValue()");
-    check(mapMaxValue(g, map2, std::greater<int>()) == 'a',
-          "Wrong mapMaxValue()");
-
-    check(mapMin(g, cmap1) != INVALID, "Wrong mapMin()");
-    check(mapMax(g, cmap2) != INVALID, "Wrong mapMax()");
-    check(mapMaxValue(g, cmap2) == C(0), "Wrong mapMaxValue()");
-
-    check(mapMin(g, composeMap(functorToMap(&createC), map2)) == a2,
-          "Wrong mapMin()");
-    check(mapMax(g, composeMap(functorToMap(&createC), map2)) == a4,
-          "Wrong mapMax()");
-    check(mapMinValue(g, composeMap(functorToMap(&createC), map2)) == C('a'),
-          "Wrong mapMinValue()");
-    check(mapMaxValue(g, composeMap(functorToMap(&createC), map2)) == C('c'),
-          "Wrong mapMaxValue()");
-
-    // mapFind(), mapFindIf()
-    check(mapFind(g, map1, 5) == n2, "Wrong mapFind()");
-    check(mapFind(g, map1, 6) == INVALID, "Wrong mapFind()");
-    check(mapFind(g, map2, 'a') == a2, "Wrong mapFind()");
-    check(mapFind(g, map2, 'e') == INVALID, "Wrong mapFind()");
-    check(mapFind(g, cmap2, C(0)) == ArcIt(g), "Wrong mapFind()");
-    check(mapFind(g, cmap2, C(1)) == INVALID, "Wrong mapFind()");
-
-    check(mapFindIf(g, map1, Less<int>(7)) == n2,
-          "Wrong mapFindIf()");
-    check(mapFindIf(g, map1, Less<int>(5)) == INVALID,
-          "Wrong mapFindIf()");
-    check(mapFindIf(g, map2, Less<char>('d')) == ArcIt(g),
-          "Wrong mapFindIf()");
-    check(mapFindIf(g, map2, Less<char>('a')) == INVALID,
-          "Wrong mapFindIf()");
-
-    // mapCount(), mapCountIf()
-    check(mapCount(g, map1, 5) == 1, "Wrong mapCount()");
-    check(mapCount(g, map1, 6) == 0, "Wrong mapCount()");
-    check(mapCount(g, map2, 'a') == 1, "Wrong mapCount()");
-    check(mapCount(g, map2, 'b') == 2, "Wrong mapCount()");
-    check(mapCount(g, map2, 'e') == 0, "Wrong mapCount()");
-    check(mapCount(g, cmap2, C(0)) == 4, "Wrong mapCount()");
-    check(mapCount(g, cmap2, C(1)) == 0, "Wrong mapCount()");
-
-    check(mapCountIf(g, map1, Less<int>(11)) == 2,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map1, Less<int>(13)) == 3,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map1, Less<int>(5)) == 0,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map2, Less<char>('d')) == 4,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map2, Less<char>('c')) == 3,
-          "Wrong mapCountIf()");
-    check(mapCountIf(g, map2, Less<char>('a')) == 0,
-          "Wrong mapCountIf()");
-
-    // MapIt, ConstMapIt
-/*
-These tests can be used after applying bugfix #330
-    typedef SmartDigraph::NodeMap<int>::MapIt MapIt;
-    typedef SmartDigraph::NodeMap<int>::ConstMapIt ConstMapIt;
-    check(*std::min_element(MapIt(map1), MapIt(INVALID)) == 5,
-          "Wrong NodeMap<>::MapIt");
-    check(*std::max_element(ConstMapIt(map1), ConstMapIt(INVALID)) == 12,
-          "Wrong NodeMap<>::MapIt");
-
-    int sum = 0;
-    std::for_each(MapIt(map1), MapIt(INVALID), Sum<int>(sum));
-    check(sum == 27, "Wrong NodeMap<>::MapIt");
-    std::for_each(ConstMapIt(map1), ConstMapIt(INVALID), Sum<int>(sum));
-    check(sum == 54, "Wrong NodeMap<>::ConstMapIt");
-*/
-
-    // mapCopy(), mapCompare(), mapFill()
-    check(mapCompare(g, map1, map1), "Wrong mapCompare()");
-    check(mapCompare(g, cmap2, cmap2), "Wrong mapCompare()");
-    check(mapCompare(g, map1, shiftMap(map1, 0)), "Wrong mapCompare()");
-    check(mapCompare(g, map2, scaleMap(map2, 1)), "Wrong mapCompare()");
-    check(!mapCompare(g, map1, shiftMap(map1, 1)), "Wrong mapCompare()");
-
-    SmartDigraph::NodeMap<int> map3(g, 0);
-    SmartDigraph::ArcMap<char> map4(g, 'a');
-
-    check(!mapCompare(g, map1, map3), "Wrong mapCompare()");
-    check(!mapCompare(g, map2, map4), "Wrong mapCompare()");
-
-    mapCopy(g, map1, map3);
-    mapCopy(g, map2, map4);
-
-    check(mapCompare(g, map1, map3), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(g, map2, map4), "Wrong mapCompare() or mapCopy()");
-
-    Undirector<SmartDigraph> ug(g);
-    Undirector<SmartDigraph>::EdgeMap<char> umap1(ug, 'x');
-    Undirector<SmartDigraph>::ArcMap<double> umap2(ug, 3.14);
-
-    check(!mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(!mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
-    check(!mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(!mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-
-    mapCopy(g, map2, umap1);
-
-    check(mapCompare(g, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(g, umap1, map2), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(ug, map2, umap1), "Wrong mapCompare() or mapCopy()");
-    check(mapCompare(ug, umap1, map2), "Wrong mapCompare() or mapCopy()");
-
-    mapCopy(g, map2, umap1);
-    mapCopy(g, umap1, map2);
-    mapCopy(ug, map2, umap1);
-    mapCopy(ug, umap1, map2);
-
-    check(!mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
-    mapCopy(ug, umap1, umap2);
-    check(mapCompare(ug, umap1, umap2), "Wrong mapCompare() or mapCopy()");
-
-    check(!mapCompare(g, map1, constMap<Node>(2)), "Wrong mapCompare()");
-    mapFill(g, map1, 2);
-    check(mapCompare(g, constMap<Node>(2), map1), "Wrong mapFill()");
-
-    check(!mapCompare(g, map2, constMap<Arc>('z')), "Wrong mapCompare()");
-    mapCopy(g, constMap<Arc>('z'), map2);
-    check(mapCompare(g, constMap<Arc>('z'), map2), "Wrong mapCopy()");
-  }
-
   return 0;
 }
Index: test/matching_test.cc
===================================================================
--- test/matching_test.cc	(revision 877)
+++ test/matching_test.cc	(revision 594)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -135,5 +135,5 @@
   mat_test.startDense();
   mat_test.run();
-
+  
   const_mat_test.matchingSize();
   const_mat_test.matching(e);
@@ -144,5 +144,5 @@
   const_mat_test.mate(n);
 
-  MaxMatching<Graph>::Status stat =
+  MaxMatching<Graph>::Status stat = 
     const_mat_test.status(n);
   const MaxMatching<Graph>::StatusMap& smap =
@@ -171,5 +171,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matchingSize();
@@ -180,5 +180,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
@@ -208,5 +208,5 @@
   mat_test.start();
   mat_test.run();
-
+  
   const_mat_test.matchingWeight();
   const_mat_test.matching(e);
@@ -216,5 +216,5 @@
   e = mmap[n];
   const_mat_test.mate(n);
-
+  
   int k = 0;
   const_mat_test.dualValue();
@@ -402,44 +402,20 @@
       edgeMap("weight", weight).run();
 
-    bool perfect;
-    {
-      MaxMatching<SmartGraph> mm(graph);
-      mm.run();
-      checkMatching(graph, mm);
-      perfect = 2 * mm.matchingSize() == countNodes(graph);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.run();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedMatching<SmartGraph> mwm(graph, weight);
-      mwm.init();
-      mwm.start();
-      checkWeightedMatching(graph, weight, mwm);
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      bool result = mwpm.run();
-
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
-    }
-
-    {
-      MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
-      mwpm.init();
-      bool result = mwpm.start();
-
-      check(result == perfect, "Perfect matching found");
-      if (perfect) {
-        checkWeightedPerfectMatching(graph, weight, mwpm);
-      }
+    MaxMatching<SmartGraph> mm(graph);
+    mm.run();
+    checkMatching(graph, mm);
+
+    MaxWeightedMatching<SmartGraph> mwm(graph, weight);
+    mwm.run();
+    checkWeightedMatching(graph, weight, mwm);
+
+    MaxWeightedPerfectMatching<SmartGraph> mwpm(graph, weight);
+    bool perfect = mwpm.run();
+
+    check(perfect == (mm.matchingSize() * 2 == countNodes(graph)),
+          "Perfect matching found");
+
+    if (perfect) {
+      checkWeightedPerfectMatching(graph, weight, mwpm);
     }
   }
Index: st/max_cardinality_search_test.cc
===================================================================
--- test/max_cardinality_search_test.cc	(revision 955)
+++ 	(revision )
@@ -1,162 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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.
- *
- */
-
-#include <iostream>
-
-#include "test_tools.h"
-#include <lemon/smart_graph.h>
-#include <lemon/max_cardinality_search.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/concepts/heap.h>
-#include <lemon/lgf_reader.h>
-
-using namespace lemon;
-using namespace std;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "@arcs\n"
-  "    label capacity\n"
-  "0 1 0     2\n"
-  "1 0 1     2\n"
-  "2 1 2     1\n"
-  "2 3 3     3\n"
-  "3 2 4     3\n"
-  "3 1 5     5\n"
-  "@attributes\n"
-  "s 0\n"
-  "x 1\n"
-  "y 2\n"
-  "z 3\n";
-
-void checkMaxCardSearchCompile() {
-
-  typedef concepts::Digraph Digraph;
-  typedef int Value;
-  typedef Digraph::Node Node;
-  typedef Digraph::Arc Arc;
-  typedef concepts::ReadMap<Arc,Value> CapMap;
-  typedef concepts::ReadWriteMap<Node,Value> CardMap;
-  typedef concepts::ReadWriteMap<Node,bool> ProcMap;
-  typedef Digraph::NodeMap<int> HeapCrossRef;
-
-  Digraph g;
-  Node n,s;
-  CapMap cap;
-  CardMap card;
-  ProcMap proc;
-  HeapCrossRef crossref(g);
-  
-  typedef MaxCardinalitySearch<Digraph,CapMap>
-    ::SetCapacityMap<CapMap>
-    ::SetCardinalityMap<CardMap>
-    ::SetProcessedMap<ProcMap>
-    ::SetStandardHeap<BinHeap<Value,HeapCrossRef> >
-    ::Create MaxCardType;
-
-  MaxCardType maxcard(g,cap);
-  const MaxCardType& const_maxcard = maxcard;
-
-  const MaxCardType::Heap& heap_const = const_maxcard.heap();
-  MaxCardType::Heap& heap = const_cast<MaxCardType::Heap&>(heap_const);
-  maxcard.heap(heap,crossref);
-  
-  maxcard.capacityMap(cap).cardinalityMap(card).processedMap(proc);
-
-  maxcard.init();
-  maxcard.addSource(s);
-  n = maxcard.nextNode();
-   maxcard.processNextNode();
-   maxcard.start();
-   maxcard.run(s);
-   maxcard.run();
- }
-
- void checkWithIntMap( std::istringstream& input)
- {
-   typedef SmartDigraph Digraph;
-   typedef Digraph::Node Node;
-   typedef Digraph::ArcMap<int> CapMap;
-
-   Digraph g;
-   Node s,x,y,z,a;
-   CapMap cap(g);
-
-   DigraphReader<Digraph>(g,input).
-     arcMap("capacity", cap).
-     node("s",s).
-     node("x",x).
-     node("y",y).
-     node("z",z).
-     run();
-
-   MaxCardinalitySearch<Digraph,CapMap> maxcard(g,cap);
-
-   maxcard.init();
-   maxcard.addSource(s);
-   maxcard.start(x);
-
-   check(maxcard.processed(s) && !maxcard.processed(x) &&
-         !maxcard.processed(y), "Wrong processed()!");
-
-   a=maxcard.nextNode();
-   check(maxcard.processNextNode()==a,
-         "Wrong nextNode() or processNextNode() return value!");
-
-   check(maxcard.processed(a), "Wrong processNextNode()!");
-
-   maxcard.start();
-   check(maxcard.cardinality(x)==2 && maxcard.cardinality(y)>=4,
-         "Wrong cardinalities!");
- }
-
- void checkWithConst1Map(std::istringstream &input) {
-   typedef SmartDigraph Digraph;
-   typedef Digraph::Node Node;
-
-   Digraph g;
-   Node s,x,y,z;
-
-  DigraphReader<Digraph>(g,input).
-    node("s",s).
-    node("x",x).
-    node("y",y).
-    node("z",z).
-    run();
-
-  MaxCardinalitySearch<Digraph> maxcard(g);
-  maxcard.run(s);
-  check(maxcard.cardinality(x)==1 &&
-        maxcard.cardinality(y)+maxcard.cardinality(z)==3,
-        "Wrong cardinalities!");
-}
-
-int main() {
-
-  std::istringstream input1(test_lgf);
-  checkWithIntMap(input1);
-
-  std::istringstream input2(test_lgf);
-  checkWithConst1Map(input2);
-}
Index: st/max_clique_test.cc
===================================================================
--- test/max_clique_test.cc	(revision 918)
+++ 	(revision )
@@ -1,188 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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.
- *
- */
-
-#include <sstream>
-#include <lemon/list_graph.h>
-#include <lemon/full_graph.h>
-#include <lemon/grid_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/grosso_locatelli_pullan_mc.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label max_clique\n"
-  "1     0\n"
-  "2     0\n"
-  "3     0\n"
-  "4     1\n"
-  "5     1\n"
-  "6     1\n"
-  "7     1\n"
-  "@edges\n"
-  "    label\n"
-  "1 2     1\n"
-  "1 3     2\n"
-  "1 4     3\n"
-  "1 6     4\n"
-  "2 3     5\n"
-  "2 5     6\n"
-  "2 7     7\n"
-  "3 4     8\n"
-  "3 5     9\n"
-  "4 5    10\n"
-  "4 6    11\n"
-  "4 7    12\n"
-  "5 6    13\n"
-  "5 7    14\n"
-  "6 7    15\n";
-      
-
-// Check with general graphs
-template <typename Param>
-void checkMaxCliqueGeneral(Param rule) {
-  typedef ListGraph GR;
-  typedef GrossoLocatelliPullanMc<GR> McAlg;
-  typedef McAlg::CliqueNodeIt CliqueIt;
-  
-  // Basic tests
-  {
-    GR g;
-    GR::NodeMap<bool> map(g);
-    McAlg mc(g);
-    mc.iterationLimit(50);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 0, "Wrong clique size");
-    check(CliqueIt(mc) == INVALID, "Wrong CliqueNodeIt");
-
-    GR::Node u = g.addNode();
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 1, "Wrong clique size");
-    mc.cliqueMap(map);
-    check(map[u], "Wrong clique map");
-    CliqueIt it1(mc);
-    check(static_cast<GR::Node>(it1) == u && ++it1 == INVALID,
-          "Wrong CliqueNodeIt");
-    
-    GR::Node v = g.addNode();
-    check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 1, "Wrong clique size");
-    mc.cliqueMap(map);
-    check((map[u] && !map[v]) || (map[v] && !map[u]), "Wrong clique map");
-    CliqueIt it2(mc);
-    check(it2 != INVALID && ++it2 == INVALID, "Wrong CliqueNodeIt");
-
-    g.addEdge(u, v);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 2, "Wrong clique size");
-    mc.cliqueMap(map);
-    check(map[u] && map[v], "Wrong clique map");
-    CliqueIt it3(mc);
-    check(it3 != INVALID && ++it3 != INVALID && ++it3 == INVALID,
-          "Wrong CliqueNodeIt");
-  }
-
-  // Test graph
-  {
-    GR g;
-    GR::NodeMap<bool> max_clique(g);
-    GR::NodeMap<bool> map(g);
-    std::istringstream input(test_lgf);
-    graphReader(g, input)
-      .nodeMap("max_clique", max_clique)
-      .run();
-    
-    McAlg mc(g);
-    mc.iterationLimit(50);
-    check(mc.run(rule) == McAlg::ITERATION_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == 4, "Wrong clique size");
-    mc.cliqueMap(map);
-    for (GR::NodeIt n(g); n != INVALID; ++n) {
-      check(map[n] == max_clique[n], "Wrong clique map");
-    }
-    int cnt = 0;
-    for (CliqueIt n(mc); n != INVALID; ++n) {
-      cnt++;
-      check(map[n] && max_clique[n], "Wrong CliqueNodeIt");
-    }
-    check(cnt == 4, "Wrong CliqueNodeIt");
-  }
-}
-
-// Check with full graphs
-template <typename Param>
-void checkMaxCliqueFullGraph(Param rule) {
-  typedef FullGraph GR;
-  typedef GrossoLocatelliPullanMc<FullGraph> McAlg;
-  typedef McAlg::CliqueNodeIt CliqueIt;
-  
-  for (int size = 0; size <= 40; size = size * 3 + 1) {
-    GR g(size);
-    GR::NodeMap<bool> map(g);
-    McAlg mc(g);
-    check(mc.run(rule) == McAlg::SIZE_LIMIT, "Wrong termination cause");
-    check(mc.cliqueSize() == size, "Wrong clique size");
-    mc.cliqueMap(map);
-    for (GR::NodeIt n(g); n != INVALID; ++n) {
-      check(map[n], "Wrong clique map");
-    }
-    int cnt = 0;
-    for (CliqueIt n(mc); n != INVALID; ++n) cnt++;
-    check(cnt == size, "Wrong CliqueNodeIt");
-  }
-}
-
-// Check with grid graphs
-template <typename Param>
-void checkMaxCliqueGridGraph(Param rule) {
-  GridGraph g(5, 7);
-  GridGraph::NodeMap<char> map(g);
-  GrossoLocatelliPullanMc<GridGraph> mc(g);
-  
-  mc.iterationLimit(100);
-  check(mc.run(rule) == mc.ITERATION_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-
-  mc.stepLimit(100);
-  check(mc.run(rule) == mc.STEP_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-
-  mc.sizeLimit(2);
-  check(mc.run(rule) == mc.SIZE_LIMIT, "Wrong termination cause");
-  check(mc.cliqueSize() == 2, "Wrong clique size");
-}
-
-
-int main() {
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::RANDOM);
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::DEGREE_BASED);
-  checkMaxCliqueGeneral(GrossoLocatelliPullanMc<ListGraph>::PENALTY_BASED);
-
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::RANDOM);
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::DEGREE_BASED);
-  checkMaxCliqueFullGraph(GrossoLocatelliPullanMc<FullGraph>::PENALTY_BASED);
-                       
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::RANDOM);
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::DEGREE_BASED);
-  checkMaxCliqueGridGraph(GrossoLocatelliPullanMc<GridGraph>::PENALTY_BASED);
-                       
-  return 0;
-}
Index: test/min_cost_arborescence_test.cc
===================================================================
--- test/min_cost_arborescence_test.cc	(revision 877)
+++ test/min_cost_arborescence_test.cc	(revision 625)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2008
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -111,5 +111,5 @@
   b = const_mcarb_test.emptyQueue();
   i = const_mcarb_test.queueSize();
-
+  
   c = const_mcarb_test.arborescenceCost();
   b = const_mcarb_test.arborescence(e);
@@ -121,10 +121,10 @@
   b = const_mcarb_test.reached(n);
   b = const_mcarb_test.processed(n);
-
+  
   i = const_mcarb_test.dualNum();
   c = const_mcarb_test.dualValue();
   i = const_mcarb_test.dualSize(i);
   c = const_mcarb_test.dualValue(i);
-
+  
   ignore_unused_variable_warning(am);
   ignore_unused_variable_warning(pm);
Index: test/min_cost_flow_test.cc
===================================================================
--- test/min_cost_flow_test.cc	(revision 877)
+++ test/min_cost_flow_test.cc	(revision 669)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -25,10 +25,6 @@
 
 #include <lemon/network_simplex.h>
-#include <lemon/capacity_scaling.h>
-#include <lemon/cost_scaling.h>
-#include <lemon/cycle_canceling.h>
 
 #include <lemon/concepts/digraph.h>
-#include <lemon/concepts/heap.h>
 #include <lemon/concept_check.h>
 
@@ -37,5 +33,4 @@
 using namespace lemon;
 
-// Test networks
 char test_lgf[] =
   "@nodes\n"
@@ -53,5 +48,5 @@
   "   11     0    0    0    0  -10    0\n"
   "   12   -20  -27    0  -30  -30  -20\n"
-  "\n"
+  "\n"                
   "@arcs\n"
   "       cost  cap low1 low2 low3\n"
@@ -82,56 +77,4 @@
   "target 12\n";
 
-char test_neg1_lgf[] =
-  "@nodes\n"
-  "label   sup\n"
-  "    1   100\n"
-  "    2     0\n"
-  "    3     0\n"
-  "    4  -100\n"
-  "    5     0\n"
-  "    6     0\n"
-  "    7     0\n"
-  "@arcs\n"
-  "      cost   low1   low2\n"
-  "1 2    100      0      0\n"
-  "1 3     30      0      0\n"
-  "2 4     20      0      0\n"
-  "3 4     80      0      0\n"
-  "3 2     50      0      0\n"
-  "5 3     10      0      0\n"
-  "5 6     80      0   1000\n"
-  "6 7     30      0  -1000\n"
-  "7 5   -120      0      0\n";
-
-char test_neg2_lgf[] =
-  "@nodes\n"
-  "label   sup\n"
-  "    1   100\n"
-  "    2  -300\n"
-  "@arcs\n"
-  "      cost\n"
-  "1 2     -1\n";
-
-
-// Test data
-typedef ListDigraph Digraph;
-DIGRAPH_TYPEDEFS(ListDigraph);
-
-Digraph gr;
-Digraph::ArcMap<int> c(gr), l1(gr), l2(gr), l3(gr), u(gr);
-Digraph::NodeMap<int> s1(gr), s2(gr), s3(gr), s4(gr), s5(gr), s6(gr);
-ConstMap<Arc, int> cc(1), cu(std::numeric_limits<int>::max());
-Node v, w;
-
-Digraph neg1_gr;
-Digraph::ArcMap<int> neg1_c(neg1_gr), neg1_l1(neg1_gr), neg1_l2(neg1_gr);
-ConstMap<Arc, int> neg1_u1(std::numeric_limits<int>::max()), neg1_u2(5000);
-Digraph::NodeMap<int> neg1_s(neg1_gr);
-
-Digraph neg2_gr;
-Digraph::ArcMap<int> neg2_c(neg2_gr);
-ConstMap<Arc, int> neg2_l(0), neg2_u(1000);
-Digraph::NodeMap<int> neg2_s(neg2_gr);
-
 
 enum SupplyType {
@@ -141,5 +84,4 @@
 };
 
-
 // Check the interface of an MCF algorithm
 template <typename GR, typename Value, typename Cost>
@@ -152,5 +94,5 @@
     void constraints() {
       checkConcept<concepts::Digraph, GR>();
-
+      
       const Constraints& me = *this;
 
@@ -158,5 +100,5 @@
       const MCF& const_mcf = mcf;
 
-      b = mcf.reset().resetParams()
+      b = mcf.reset()
              .lowerMap(me.lower)
              .upperMap(me.upper)
@@ -181,5 +123,5 @@
     typedef concepts::WriteMap<Arc, Value> FlowMap;
     typedef concepts::WriteMap<Node, Cost> PotMap;
-
+  
     GR g;
     VAM lower;
@@ -235,5 +177,5 @@
            typename CM, typename SM, typename FM, typename PM >
 bool checkPotential( const GR& gr, const LM& lower, const UM& upper,
-                     const CM& cost, const SM& supply, const FM& flow,
+                     const CM& cost, const SM& supply, const FM& flow, 
                      const PM& pi, SupplyType type )
 {
@@ -248,5 +190,5 @@
           (red_cost < 0 && flow[e] == upper[e]);
   }
-
+  
   for (NodeIt n(gr); opt && n != INVALID; ++n) {
     typename SM::Value sum = 0;
@@ -261,5 +203,5 @@
     }
   }
-
+  
   return opt;
 }
@@ -286,5 +228,5 @@
     }
   }
-
+  
   for (NodeIt n(gr); n != INVALID; ++n) {
     dual_cost -= red_supply[n] * pi[n];
@@ -295,5 +237,5 @@
     dual_cost -= (upper[a] - lower[a]) * std::max(-red_cost, 0);
   }
-
+  
   return dual_cost == total;
 }
@@ -327,97 +269,28 @@
 }
 
-template < typename MCF, typename Param >
-void runMcfGeqTests( Param param,
-                     const std::string &test_str = "",
-                     bool full_neg_cost_support = false )
-{
-  MCF mcf1(gr), mcf2(neg1_gr), mcf3(neg2_gr);
-
-  // Basic tests
-  mcf1.upperMap(u).costMap(c).supplyMap(s1);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s1,
-           mcf1.OPTIMAL, true,     5240, test_str + "-1");
-  mcf1.stSupply(v, w, 27);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s2,
-           mcf1.OPTIMAL, true,     7620, test_str + "-2");
-  mcf1.lowerMap(l2).supplyMap(s1);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s1,
-           mcf1.OPTIMAL, true,     5970, test_str + "-3");
-  mcf1.stSupply(v, w, 27);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s2,
-           mcf1.OPTIMAL, true,     8010, test_str + "-4");
-  mcf1.resetParams().supplyMap(s1);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s1,
-           mcf1.OPTIMAL, true,       74, test_str + "-5");
-  mcf1.lowerMap(l2).stSupply(v, w, 27);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, cu, cc, s2,
-           mcf1.OPTIMAL, true,       94, test_str + "-6");
-  mcf1.reset();
-  checkMcf(mcf1, mcf1.run(param), gr, l1, cu, cc, s3,
-           mcf1.OPTIMAL, true,        0, test_str + "-7");
-  mcf1.lowerMap(l2).upperMap(u);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, cc, s3,
-           mcf1.INFEASIBLE, false,    0, test_str + "-8");
-  mcf1.lowerMap(l3).upperMap(u).costMap(c).supplyMap(s4);
-  checkMcf(mcf1, mcf1.run(param), gr, l3, u, c, s4,
-           mcf1.OPTIMAL, true,     6360, test_str + "-9");
-
-  // Tests for the GEQ form
-  mcf1.resetParams().upperMap(u).costMap(c).supplyMap(s5);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s5,
-           mcf1.OPTIMAL, true,     3530, test_str + "-10", GEQ);
-  mcf1.lowerMap(l2);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s5,
-           mcf1.OPTIMAL, true,     4540, test_str + "-11", GEQ);
-  mcf1.supplyMap(s6);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s6,
-           mcf1.INFEASIBLE, false,    0, test_str + "-12", GEQ);
-
-  // Tests with negative costs
-  mcf2.lowerMap(neg1_l1).costMap(neg1_c).supplyMap(neg1_s);
-  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u1, neg1_c, neg1_s,
-           mcf2.UNBOUNDED, false,     0, test_str + "-13");
-  mcf2.upperMap(neg1_u2);
-  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l1, neg1_u2, neg1_c, neg1_s,
-           mcf2.OPTIMAL, true,   -40000, test_str + "-14");
-  mcf2.resetParams().lowerMap(neg1_l2).costMap(neg1_c).supplyMap(neg1_s);
-  checkMcf(mcf2, mcf2.run(param), neg1_gr, neg1_l2, neg1_u1, neg1_c, neg1_s,
-           mcf2.UNBOUNDED, false,     0, test_str + "-15");
-
-  mcf3.costMap(neg2_c).supplyMap(neg2_s);
-  if (full_neg_cost_support) {
-    checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
-             mcf3.OPTIMAL, true,   -300, test_str + "-16", GEQ);
-  } else {
-    checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
-             mcf3.UNBOUNDED, false,   0, test_str + "-17", GEQ);
-  }
-  mcf3.upperMap(neg2_u);
-  checkMcf(mcf3, mcf3.run(param), neg2_gr, neg2_l, neg2_u, neg2_c, neg2_s,
-           mcf3.OPTIMAL, true,     -300, test_str + "-18", GEQ);
-}
-
-template < typename MCF, typename Param >
-void runMcfLeqTests( Param param,
-                     const std::string &test_str = "" )
-{
-  // Tests for the LEQ form
-  MCF mcf1(gr);
-  mcf1.supplyType(mcf1.LEQ);
-  mcf1.upperMap(u).costMap(c).supplyMap(s6);
-  checkMcf(mcf1, mcf1.run(param), gr, l1, u, c, s6,
-           mcf1.OPTIMAL, true,   5080, test_str + "-19", LEQ);
-  mcf1.lowerMap(l2);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s6,
-           mcf1.OPTIMAL, true,   5930, test_str + "-20", LEQ);
-  mcf1.supplyMap(s5);
-  checkMcf(mcf1, mcf1.run(param), gr, l2, u, c, s5,
-           mcf1.INFEASIBLE, false,  0, test_str + "-21", LEQ);
-}
-
-
 int main()
 {
-  // Read the test networks
+  // Check the interfaces
+  {
+    typedef concepts::Digraph GR;
+    checkConcept< McfClassConcept<GR, int, int>,
+                  NetworkSimplex<GR> >();
+    checkConcept< McfClassConcept<GR, double, double>,
+                  NetworkSimplex<GR, double> >();
+    checkConcept< McfClassConcept<GR, int, double>,
+                  NetworkSimplex<GR, int, double> >();
+  }
+
+  // Run various MCF tests
+  typedef ListDigraph Digraph;
+  DIGRAPH_TYPEDEFS(ListDigraph);
+
+  // Read the test digraph
+  Digraph gr;
+  Digraph::ArcMap<int> c(gr), l1(gr), l2(gr), l3(gr), u(gr);
+  Digraph::NodeMap<int> s1(gr), s2(gr), s3(gr), s4(gr), s5(gr), s6(gr);
+  ConstMap<Arc, int> cc(1), cu(std::numeric_limits<int>::max());
+  Node v, w;
+
   std::istringstream input(test_lgf);
   DigraphReader<Digraph>(gr, input)
@@ -436,105 +309,140 @@
     .node("target", w)
     .run();
-
-  std::istringstream neg_inp1(test_neg1_lgf);
-  DigraphReader<Digraph>(neg1_gr, neg_inp1)
-    .arcMap("cost", neg1_c)
-    .arcMap("low1", neg1_l1)
-    .arcMap("low2", neg1_l2)
-    .nodeMap("sup", neg1_s)
-    .run();
-
-  std::istringstream neg_inp2(test_neg2_lgf);
-  DigraphReader<Digraph>(neg2_gr, neg_inp2)
-    .arcMap("cost", neg2_c)
-    .nodeMap("sup", neg2_s)
-    .run();
-
-  // Check the interface of NetworkSimplex
+  
+  // Build test digraphs with negative costs
+  Digraph neg_gr;
+  Node n1 = neg_gr.addNode();
+  Node n2 = neg_gr.addNode();
+  Node n3 = neg_gr.addNode();
+  Node n4 = neg_gr.addNode();
+  Node n5 = neg_gr.addNode();
+  Node n6 = neg_gr.addNode();
+  Node n7 = neg_gr.addNode();
+  
+  Arc a1 = neg_gr.addArc(n1, n2);
+  Arc a2 = neg_gr.addArc(n1, n3);
+  Arc a3 = neg_gr.addArc(n2, n4);
+  Arc a4 = neg_gr.addArc(n3, n4);
+  Arc a5 = neg_gr.addArc(n3, n2);
+  Arc a6 = neg_gr.addArc(n5, n3);
+  Arc a7 = neg_gr.addArc(n5, n6);
+  Arc a8 = neg_gr.addArc(n6, n7);
+  Arc a9 = neg_gr.addArc(n7, n5);
+  
+  Digraph::ArcMap<int> neg_c(neg_gr), neg_l1(neg_gr, 0), neg_l2(neg_gr, 0);
+  ConstMap<Arc, int> neg_u1(std::numeric_limits<int>::max()), neg_u2(5000);
+  Digraph::NodeMap<int> neg_s(neg_gr, 0);
+  
+  neg_l2[a7] =  1000;
+  neg_l2[a8] = -1000;
+  
+  neg_s[n1] =  100;
+  neg_s[n4] = -100;
+  
+  neg_c[a1] =  100;
+  neg_c[a2] =   30;
+  neg_c[a3] =   20;
+  neg_c[a4] =   80;
+  neg_c[a5] =   50;
+  neg_c[a6] =   10;
+  neg_c[a7] =   80;
+  neg_c[a8] =   30;
+  neg_c[a9] = -120;
+
+  Digraph negs_gr;
+  Digraph::NodeMap<int> negs_s(negs_gr);
+  Digraph::ArcMap<int> negs_c(negs_gr);
+  ConstMap<Arc, int> negs_l(0), negs_u(1000);
+  n1 = negs_gr.addNode();
+  n2 = negs_gr.addNode();
+  negs_s[n1] = 100;
+  negs_s[n2] = -300;
+  negs_c[negs_gr.addArc(n1, n2)] = -1;
+
+
+  // A. Test NetworkSimplex with the default pivot rule
   {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  NetworkSimplex<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  NetworkSimplex<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  NetworkSimplex<GR, int, double> >();
-  }
-
-  // Check the interface of CapacityScaling
+    NetworkSimplex<Digraph> mcf(gr);
+
+    // Check the equality form
+    mcf.upperMap(u).costMap(c);
+    checkMcf(mcf, mcf.supplyMap(s1).run(),
+             gr, l1, u, c, s1, mcf.OPTIMAL, true,   5240, "#A1");
+    checkMcf(mcf, mcf.stSupply(v, w, 27).run(),
+             gr, l1, u, c, s2, mcf.OPTIMAL, true,   7620, "#A2");
+    mcf.lowerMap(l2);
+    checkMcf(mcf, mcf.supplyMap(s1).run(),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#A3");
+    checkMcf(mcf, mcf.stSupply(v, w, 27).run(),
+             gr, l2, u, c, s2, mcf.OPTIMAL, true,   8010, "#A4");
+    mcf.reset();
+    checkMcf(mcf, mcf.supplyMap(s1).run(),
+             gr, l1, cu, cc, s1, mcf.OPTIMAL, true,   74, "#A5");
+    checkMcf(mcf, mcf.lowerMap(l2).stSupply(v, w, 27).run(),
+             gr, l2, cu, cc, s2, mcf.OPTIMAL, true,   94, "#A6");
+    mcf.reset();
+    checkMcf(mcf, mcf.run(),
+             gr, l1, cu, cc, s3, mcf.OPTIMAL, true,    0, "#A7");
+    checkMcf(mcf, mcf.lowerMap(l2).upperMap(u).run(),
+             gr, l2, u, cc, s3, mcf.INFEASIBLE, false, 0, "#A8");
+    mcf.reset().lowerMap(l3).upperMap(u).costMap(c).supplyMap(s4);
+    checkMcf(mcf, mcf.run(),
+             gr, l3, u, c, s4, mcf.OPTIMAL, true,   6360, "#A9");
+
+    // Check the GEQ form
+    mcf.reset().upperMap(u).costMap(c).supplyMap(s5);
+    checkMcf(mcf, mcf.run(),
+             gr, l1, u, c, s5, mcf.OPTIMAL, true,   3530, "#A10", GEQ);
+    mcf.supplyType(mcf.GEQ);
+    checkMcf(mcf, mcf.lowerMap(l2).run(),
+             gr, l2, u, c, s5, mcf.OPTIMAL, true,   4540, "#A11", GEQ);
+    mcf.supplyMap(s6);
+    checkMcf(mcf, mcf.run(),
+             gr, l2, u, c, s6, mcf.INFEASIBLE, false,  0, "#A12", GEQ);
+
+    // Check the LEQ form
+    mcf.reset().supplyType(mcf.LEQ);
+    mcf.upperMap(u).costMap(c).supplyMap(s6);
+    checkMcf(mcf, mcf.run(),
+             gr, l1, u, c, s6, mcf.OPTIMAL, true,   5080, "#A13", LEQ);
+    checkMcf(mcf, mcf.lowerMap(l2).run(),
+             gr, l2, u, c, s6, mcf.OPTIMAL, true,   5930, "#A14", LEQ);
+    mcf.supplyMap(s5);
+    checkMcf(mcf, mcf.run(),
+             gr, l2, u, c, s5, mcf.INFEASIBLE, false,  0, "#A15", LEQ);
+
+    // Check negative costs
+    NetworkSimplex<Digraph> neg_mcf(neg_gr);
+    neg_mcf.lowerMap(neg_l1).costMap(neg_c).supplyMap(neg_s);
+    checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l1, neg_u1,
+      neg_c, neg_s, neg_mcf.UNBOUNDED, false,    0, "#A16");
+    neg_mcf.upperMap(neg_u2);
+    checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l1, neg_u2,
+      neg_c, neg_s, neg_mcf.OPTIMAL, true,  -40000, "#A17");
+    neg_mcf.reset().lowerMap(neg_l2).costMap(neg_c).supplyMap(neg_s);
+    checkMcf(neg_mcf, neg_mcf.run(), neg_gr, neg_l2, neg_u1,
+      neg_c, neg_s, neg_mcf.UNBOUNDED, false,    0, "#A18");
+      
+    NetworkSimplex<Digraph> negs_mcf(negs_gr);
+    negs_mcf.costMap(negs_c).supplyMap(negs_s);
+    checkMcf(negs_mcf, negs_mcf.run(), negs_gr, negs_l, negs_u,
+      negs_c, negs_s, negs_mcf.OPTIMAL, true, -300, "#A19", GEQ);
+  }
+
+  // B. Test NetworkSimplex with each pivot rule
   {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  CapacityScaling<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  CapacityScaling<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  CapacityScaling<GR, int, double> >();
-    typedef CapacityScaling<GR>::
-      SetHeap<concepts::Heap<int, RangeMap<int> > >::Create CAS;
-    checkConcept< McfClassConcept<GR, int, int>, CAS >();
-  }
-
-  // Check the interface of CostScaling
-  {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  CostScaling<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  CostScaling<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  CostScaling<GR, int, double> >();
-    typedef CostScaling<GR>::
-      SetLargeCost<double>::Create COS;
-    checkConcept< McfClassConcept<GR, int, int>, COS >();
-  }
-
-  // Check the interface of CycleCanceling
-  {
-    typedef concepts::Digraph GR;
-    checkConcept< McfClassConcept<GR, int, int>,
-                  CycleCanceling<GR> >();
-    checkConcept< McfClassConcept<GR, double, double>,
-                  CycleCanceling<GR, double> >();
-    checkConcept< McfClassConcept<GR, int, double>,
-                  CycleCanceling<GR, int, double> >();
-  }
-
-  // Test NetworkSimplex
-  {
-    typedef NetworkSimplex<Digraph> MCF;
-    runMcfGeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE", true);
-    runMcfLeqTests<MCF>(MCF::FIRST_ELIGIBLE, "NS-FE");
-    runMcfGeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE", true);
-    runMcfLeqTests<MCF>(MCF::BEST_ELIGIBLE,  "NS-BE");
-    runMcfGeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS", true);
-    runMcfLeqTests<MCF>(MCF::BLOCK_SEARCH,   "NS-BS");
-    runMcfGeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL", true);
-    runMcfLeqTests<MCF>(MCF::CANDIDATE_LIST, "NS-CL");
-    runMcfGeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL", true);
-    runMcfLeqTests<MCF>(MCF::ALTERING_LIST,  "NS-AL");
-  }
-
-  // Test CapacityScaling
-  {
-    typedef CapacityScaling<Digraph> MCF;
-    runMcfGeqTests<MCF>(0, "SSP");
-    runMcfGeqTests<MCF>(2, "CAS");
-  }
-
-  // Test CostScaling
-  {
-    typedef CostScaling<Digraph> MCF;
-    runMcfGeqTests<MCF>(MCF::PUSH, "COS-PR");
-    runMcfGeqTests<MCF>(MCF::AUGMENT, "COS-AR");
-    runMcfGeqTests<MCF>(MCF::PARTIAL_AUGMENT, "COS-PAR");
-  }
-
-  // Test CycleCanceling
-  {
-    typedef CycleCanceling<Digraph> MCF;
-    runMcfGeqTests<MCF>(MCF::SIMPLE_CYCLE_CANCELING, "SCC");
-    runMcfGeqTests<MCF>(MCF::MINIMUM_MEAN_CYCLE_CANCELING, "MMCC");
-    runMcfGeqTests<MCF>(MCF::CANCEL_AND_TIGHTEN, "CAT");
+    NetworkSimplex<Digraph> mcf(gr);
+    mcf.supplyMap(s1).costMap(c).upperMap(u).lowerMap(l2);
+
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::FIRST_ELIGIBLE),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B1");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::BEST_ELIGIBLE),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B2");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::BLOCK_SEARCH),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B3");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::CANDIDATE_LIST),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B4");
+    checkMcf(mcf, mcf.run(NetworkSimplex<Digraph>::ALTERING_LIST),
+             gr, l2, u, c, s1, mcf.OPTIMAL, true,   5970, "#B5");
   }
 
Index: st/min_mean_cycle_test.cc
===================================================================
--- test/min_mean_cycle_test.cc	(revision 877)
+++ 	(revision )
@@ -1,216 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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.
- *
- */
-
-#include <iostream>
-#include <sstream>
-
-#include <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/path.h>
-#include <lemon/concepts/digraph.h>
-#include <lemon/concept_check.h>
-
-#include <lemon/karp_mmc.h>
-#include <lemon/hartmann_orlin_mmc.h>
-#include <lemon/howard_mmc.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-
-char test_lgf[] =
-  "@nodes\n"
-  "label\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "6\n"
-  "7\n"
-  "@arcs\n"
-  "    len1 len2 len3 len4  c1 c2 c3 c4\n"
-  "1 2    1    1    1    1   0  0  0  0\n"
-  "2 4    5    5    5    5   1  0  0  0\n"
-  "2 3    8    8    8    8   0  0  0  0\n"
-  "3 2   -2    0    0    0   1  0  0  0\n"
-  "3 4    4    4    4    4   0  0  0  0\n"
-  "3 7   -4   -4   -4   -4   0  0  0  0\n"
-  "4 1    2    2    2    2   0  0  0  0\n"
-  "4 3    3    3    3    3   1  0  0  0\n"
-  "4 4    3    3    0    0   0  0  1  0\n"
-  "5 2    4    4    4    4   0  0  0  0\n"
-  "5 6    3    3    3    3   0  1  0  0\n"
-  "6 5    2    2    2    2   0  1  0  0\n"
-  "6 4   -1   -1   -1   -1   0  0  0  0\n"
-  "6 7    1    1    1    1   0  0  0  0\n"
-  "7 7    4    4    4   -1   0  0  0  1\n";
-
-
-// Check the interface of an MMC algorithm
-template <typename GR, typename Cost>
-struct MmcClassConcept
-{
-  template <typename MMC>
-  struct Constraints {
-    void constraints() {
-      const Constraints& me = *this;
-
-      typedef typename MMC
-        ::template SetPath<ListPath<GR> >
-        ::template SetLargeCost<Cost>
-        ::Create MmcAlg;
-      MmcAlg mmc(me.g, me.cost);
-      const MmcAlg& const_mmc = mmc;
-
-      typename MmcAlg::Tolerance tol = const_mmc.tolerance();
-      mmc.tolerance(tol);
-
-      b = mmc.cycle(p).run();
-      b = mmc.findCycleMean();
-      b = mmc.findCycle();
-
-      v = const_mmc.cycleCost();
-      i = const_mmc.cycleSize();
-      d = const_mmc.cycleMean();
-      p = const_mmc.cycle();
-    }
-
-    typedef concepts::ReadMap<typename GR::Arc, Cost> CM;
-
-    GR g;
-    CM cost;
-    ListPath<GR> p;
-    Cost v;
-    int i;
-    double d;
-    bool b;
-  };
-};
-
-// Perform a test with the given parameters
-template <typename MMC>
-void checkMmcAlg(const SmartDigraph& gr,
-                 const SmartDigraph::ArcMap<int>& lm,
-                 const SmartDigraph::ArcMap<int>& cm,
-                 int cost, int size) {
-  MMC alg(gr, lm);
-  alg.findCycleMean();
-  check(alg.cycleMean() == static_cast<double>(cost) / size,
-        "Wrong cycle mean");
-  alg.findCycle();
-  check(alg.cycleCost() == cost && alg.cycleSize() == size,
-        "Wrong path");
-  SmartDigraph::ArcMap<int> cycle(gr, 0);
-  for (typename MMC::Path::ArcIt a(alg.cycle()); a != INVALID; ++a) {
-    ++cycle[a];
-  }
-  for (SmartDigraph::ArcIt a(gr); a != INVALID; ++a) {
-    check(cm[a] == cycle[a], "Wrong path");
-  }
-}
-
-// Class for comparing types
-template <typename T1, typename T2>
-struct IsSameType {
-  static const int result = 0;
-};
-
-template <typename T>
-struct IsSameType<T,T> {
-  static const int result = 1;
-};
-
-
-int main() {
-  #ifdef LEMON_HAVE_LONG_LONG
-    typedef long long long_int;
-  #else
-    typedef long long_int;
-  #endif
-
-  // Check the interface
-  {
-    typedef concepts::Digraph GR;
-
-    // KarpMmc
-    checkConcept< MmcClassConcept<GR, int>,
-                  KarpMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
-    checkConcept< MmcClassConcept<GR, float>,
-                  KarpMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    // HartmannOrlinMmc
-    checkConcept< MmcClassConcept<GR, int>,
-                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
-    checkConcept< MmcClassConcept<GR, float>,
-                  HartmannOrlinMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    // HowardMmc
-    checkConcept< MmcClassConcept<GR, int>,
-                  HowardMmc<GR, concepts::ReadMap<GR::Arc, int> > >();
-    checkConcept< MmcClassConcept<GR, float>,
-                  HowardMmc<GR, concepts::ReadMap<GR::Arc, float> > >();
-
-    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, int> >
-           ::LargeCost, long_int>::result == 1), "Wrong LargeCost type");
-    check((IsSameType<HowardMmc<GR, concepts::ReadMap<GR::Arc, float> >
-           ::LargeCost, double>::result == 1), "Wrong LargeCost type");
-  }
-
-  // Run various tests
-  {
-    typedef SmartDigraph GR;
-    DIGRAPH_TYPEDEFS(GR);
-
-    GR gr;
-    IntArcMap l1(gr), l2(gr), l3(gr), l4(gr);
-    IntArcMap c1(gr), c2(gr), c3(gr), c4(gr);
-
-    std::istringstream input(test_lgf);
-    digraphReader(gr, input).
-      arcMap("len1", l1).
-      arcMap("len2", l2).
-      arcMap("len3", l3).
-      arcMap("len4", l4).
-      arcMap("c1", c1).
-      arcMap("c2", c2).
-      arcMap("c3", c3).
-      arcMap("c4", c4).
-      run();
-
-    // Karp
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<KarpMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-
-    // HartmannOrlin
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<HartmannOrlinMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-
-    // Howard
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l1, c1,  6, 3);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l2, c2,  5, 2);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l3, c3,  0, 1);
-    checkMmcAlg<HowardMmc<GR, IntArcMap> >(gr, l4, c4, -1, 1);
-  }
-
-  return 0;
-}
Index: st/nagamochi_ibaraki_test.cc
===================================================================
--- test/nagamochi_ibaraki_test.cc	(revision 913)
+++ 	(revision )
@@ -1,141 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2010
- * 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.
- *
- */
-
-#include <sstream>
-
-#include <lemon/smart_graph.h>
-#include <lemon/adaptors.h>
-#include <lemon/concepts/graph.h>
-#include <lemon/concepts/maps.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/nagamochi_ibaraki.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-using namespace std;
-
-const std::string lgf =
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@edges\n"
-  "     cap1 cap2 cap3\n"
-  "0 1  1    1    1   \n"
-  "0 2  2    2    4   \n"
-  "1 2  4    4    4   \n"
-  "3 4  1    1    1   \n"
-  "3 5  2    2    4   \n"
-  "4 5  4    4    4   \n"
-  "2 3  1    6    6   \n";
-
-void checkNagamochiIbarakiCompile()
-{
-  typedef int Value;
-  typedef concepts::Graph Graph;
-
-  typedef Graph::Node Node;
-  typedef Graph::Edge Edge;
-  typedef concepts::ReadMap<Edge, Value> CapMap;
-  typedef concepts::WriteMap<Node, bool> CutMap;
-
-  Graph g;
-  Node n;
-  CapMap cap;
-  CutMap cut;
-  Value v;
-  bool b;
-
-  NagamochiIbaraki<Graph, CapMap> ni_test(g, cap);
-  const NagamochiIbaraki<Graph, CapMap>& const_ni_test = ni_test;
-
-  ni_test.init();
-  ni_test.start();
-  b = ni_test.processNextPhase();
-  ni_test.run();
-
-  v = const_ni_test.minCutValue();
-  v = const_ni_test.minCutMap(cut);
-}
-
-template <typename Graph, typename CapMap, typename CutMap>
-typename CapMap::Value
-  cutValue(const Graph& graph, const CapMap& cap, const CutMap& cut)
-{
-  typename CapMap::Value sum = 0;
-  for (typename Graph::EdgeIt e(graph); e != INVALID; ++e) {
-    if (cut[graph.u(e)] != cut[graph.v(e)]) {
-      sum += cap[e];
-    }
-  }
-  return sum;
-}
-
-int main() {
-  SmartGraph graph;
-  SmartGraph::EdgeMap<int> cap1(graph), cap2(graph), cap3(graph);
-  SmartGraph::NodeMap<bool> cut(graph);
-
-  istringstream input(lgf);
-  graphReader(graph, input)
-    .edgeMap("cap1", cap1)
-    .edgeMap("cap2", cap2)
-    .edgeMap("cap3", cap3)
-    .run();
-
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap1);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 1, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap1, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap2);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 3, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap2, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph> ni(graph, cap3);
-    ni.run();
-    ni.minCutMap(cut);
-
-    check(ni.minCutValue() == 5, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap3, cut), "Wrong cut value");
-  }
-  {
-    NagamochiIbaraki<SmartGraph>::SetUnitCapacity::Create ni(graph);
-    ni.run();
-    ni.minCutMap(cut);
-
-    ConstMap<SmartGraph::Edge, int> cap4(1);
-    check(ni.minCutValue() == 1, "Wrong cut value");
-    check(ni.minCutValue() == cutValue(graph, cap4, cut), "Wrong cut value");
-  }
-
-  return 0;
-}
Index: test/path_test.cc
===================================================================
--- test/path_test.cc	(revision 440)
+++ test/path_test.cc	(revision 990)
@@ -39,6 +39,35 @@
 }
 
+// Check if proper copy consructor is called (use valgrind for testing)
+template<class _Path>
+void checkCopy()
+{
+  ListDigraph g;
+  ListDigraph::Arc a  = g.addArc(g.addNode(), g.addNode());
+  
+  _Path p,q;
+  p.addBack(a);
+  q=p;
+  _Path r(p);
+  StaticPath<ListDigraph> s(r);
+}
+  
 int main() {
   check_concepts();
+
+  checkCopy<Path<ListDigraph> >();
+  checkCopy<SimplePath<ListDigraph> >();
+  checkCopy<ListPath<ListDigraph> >();
+
+  ListDigraph g;
+  ListDigraph::Arc a  = g.addArc(g.addNode(), g.addNode());
+  
+  Path<ListDigraph> p;
+  StaticPath<ListDigraph> q,r;
+  p.addBack(a);
+  q=p;
+  r=q;
+  StaticPath<ListDigraph> s(q);
+
   return 0;
 }
Index: st/planarity_test.cc
===================================================================
--- test/planarity_test.cc	(revision 798)
+++ 	(revision )
@@ -1,262 +1,0 @@
-/* -*- mode: C++; indent-tabs-mode: nil; -*-
- *
- * This file is a part of LEMON, a generic C++ optimization library.
- *
- * Copyright (C) 2003-2009
- * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
- * (Egervary Research Group on Combinatorial Optimization, EGRES).
- *
- * Permission to use, modify and distribute this software is granted
- * provided that this copyright notice appears in all copies. For
- * precise terms see the accompanying LICENSE file.
- *
- * This software is provided "AS IS" with no warranty of any kind,
- * express or implied, and with no claim as to its suitability for any
- * purpose.
- *
- */
-
-#include <iostream>
-
-#include <lemon/planarity.h>
-
-#include <lemon/smart_graph.h>
-#include <lemon/lgf_reader.h>
-#include <lemon/connectivity.h>
-#include <lemon/dim2.h>
-
-#include "test_tools.h"
-
-using namespace lemon;
-using namespace lemon::dim2;
-
-const int lgfn = 4;
-const std::string lgf[lgfn] = {
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "@edges\n"
-  "     label\n"
-  "0 1  0\n"
-  "0 2  0\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "1 2  0\n"
-  "1 3  0\n"
-  "1 4  0\n"
-  "2 3  0\n"
-  "2 4  0\n"
-  "3 4  0\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "@edges\n"
-  "     label\n"
-  "0 1  0\n"
-  "0 2  0\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "1 2  0\n"
-  "1 3  0\n"
-  "2 3  0\n"
-  "2 4  0\n"
-  "3 4  0\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@edges\n"
-  "     label\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "0 5  0\n"
-  "1 3  0\n"
-  "1 4  0\n"
-  "1 5  0\n"
-  "2 3  0\n"
-  "2 4  0\n"
-  "2 5  0\n",
-
-  "@nodes\n"
-  "label\n"
-  "0\n"
-  "1\n"
-  "2\n"
-  "3\n"
-  "4\n"
-  "5\n"
-  "@edges\n"
-  "     label\n"
-  "0 3  0\n"
-  "0 4  0\n"
-  "0 5  0\n"
-  "1 3  0\n"
-  "1 4  0\n"
-  "1 5  0\n"
-  "2 3  0\n"
-  "2 5  0\n"
-};
-
-
-
-typedef SmartGraph Graph;
-GRAPH_TYPEDEFS(Graph);
-
-typedef PlanarEmbedding<SmartGraph> PE;
-typedef PlanarDrawing<SmartGraph> PD;
-typedef PlanarColoring<SmartGraph> PC;
-
-void checkEmbedding(const Graph& graph, PE& pe) {
-  int face_num = 0;
-
-  Graph::ArcMap<int> face(graph, -1);
-
-  for (ArcIt a(graph); a != INVALID; ++a) {
-    if (face[a] == -1) {
-      Arc b = a;
-      while (face[b] == -1) {
-        face[b] = face_num;
-        b = pe.next(graph.oppositeArc(b));
-      }
-      check(face[b] == face_num, "Wrong face");
-      ++face_num;
-    }
-  }
-  check(face_num + countNodes(graph) - countConnectedComponents(graph) ==
-        countEdges(graph) + 1, "Euler test does not passed");
-}
-
-void checkKuratowski(const Graph& graph, PE& pe) {
-  std::map<int, int> degs;
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    int deg = 0;
-    for (IncEdgeIt e(graph, n); e != INVALID; ++e) {
-      if (pe.kuratowski(e)) {
-        ++deg;
-      }
-    }
-    ++degs[deg];
-  }
-  for (std::map<int, int>::iterator it = degs.begin(); it != degs.end(); ++it) {
-    check(it->first == 0 || it->first == 2 ||
-          (it->first == 3 && it->second == 6) ||
-          (it->first == 4 && it->second == 5),
-          "Wrong degree in Kuratowski graph");
-  }
-
-  // Not full test
-  check((degs[3] == 0) != (degs[4] == 0), "Wrong Kuratowski graph");
-}
-
-bool intersect(Point<int> e1, Point<int> e2, Point<int> f1, Point<int> f2) {
-  int l, r;
-  if (std::min(e1.x, e2.x) > std::max(f1.x, f2.x)) return false;
-  if (std::max(e1.x, e2.x) < std::min(f1.x, f2.x)) return false;
-  if (std::min(e1.y, e2.y) > std::max(f1.y, f2.y)) return false;
-  if (std::max(e1.y, e2.y) < std::min(f1.y, f2.y)) return false;
-
-  l = (e2.x - e1.x) * (f1.y - e1.y) - (e2.y - e1.y) * (f1.x - e1.x);
-  r = (e2.x - e1.x) * (f2.y - e1.y) - (e2.y - e1.y) * (f2.x - e1.x);
-  if (!((l >= 0 && r <= 0) || (l <= 0 && r >= 0))) return false;
-  l = (f2.x - f1.x) * (e1.y - f1.y) - (f2.y - f1.y) * (e1.x - f1.x);
-  r = (f2.x - f1.x) * (e2.y - f1.y) - (f2.y - f1.y) * (e2.x - f1.x);
-  if (!((l >= 0 && r <= 0) || (l <= 0 && r >= 0))) return false;
-  return true;
-}
-
-bool collinear(Point<int> p, Point<int> q, Point<int> r) {
-  int v;
-  v = (q.x - p.x) * (r.y - p.y) - (q.y - p.y) * (r.x - p.x);
-  if (v != 0) return false;
-  v = (q.x - p.x) * (r.x - p.x) + (q.y - p.y) * (r.y - p.y);
-  if (v < 0) return false;
-  return true;
-}
-
-void checkDrawing(const Graph& graph, PD& pd) {
-  for (Graph::NodeIt n(graph); n != INVALID; ++n) {
-    Graph::NodeIt m(n);
-    for (++m; m != INVALID; ++m) {
-      check(pd[m] != pd[n], "Two nodes with identical coordinates");
-    }
-  }
-
-  for (Graph::EdgeIt e(graph); e != INVALID; ++e) {
-    for (Graph::EdgeIt f(e); f != e; ++f) {
-      Point<int> e1 = pd[graph.u(e)];
-      Point<int> e2 = pd[graph.v(e)];
-      Point<int> f1 = pd[graph.u(f)];
-      Point<int> f2 = pd[graph.v(f)];
-
-      if (graph.u(e) == graph.u(f)) {
-        check(!collinear(e1, e2, f2), "Wrong drawing");
-      } else if (graph.u(e) == graph.v(f)) {
-        check(!collinear(e1, e2, f1), "Wrong drawing");
-      } else if (graph.v(e) == graph.u(f)) {
-        check(!collinear(e2, e1, f2), "Wrong drawing");
-      } else if (graph.v(e) == graph.v(f)) {
-        check(!collinear(e2, e1, f1), "Wrong drawing");
-      } else {
-        check(!intersect(e1, e2, f1, f2), "Wrong drawing");
-      }
-    }
-  }
-}
-
-void checkColoring(const Graph& graph, PC& pc, int num) {
-  for (NodeIt n(graph); n != INVALID; ++n) {
-    check(pc.colorIndex(n) >= 0 && pc.colorIndex(n) < num,
-          "Wrong coloring");
-  }
-  for (EdgeIt e(graph); e != INVALID; ++e) {
-    check(pc.colorIndex(graph.u(e)) != pc.colorIndex(graph.v(e)),
-          "Wrong coloring");
-  }
-}
-
-int main() {
-
-  for (int i = 0; i < lgfn; ++i) {
-    std::istringstream lgfs(lgf[i]);
-
-    SmartGraph graph;
-    graphReader(graph, lgfs).run();
-
-    check(simpleGraph(graph), "Test graphs must be simple");
-
-    PE pe(graph);
-    bool planar = pe.run();
-    check(checkPlanarity(graph) == planar, "Planarity checking failed");
-
-    if (planar) {
-      checkEmbedding(graph, pe);
-
-      PlanarDrawing<Graph> pd(graph);
-      pd.run(pe.embeddingMap());
-      checkDrawing(graph, pd);
-
-      PlanarColoring<Graph> pc(graph);
-      pc.runFiveColoring(pe.embeddingMap());
-      checkColoring(graph, pc, 5);
-
-    } else {
-      checkKuratowski(graph, pe);
-    }
-  }
-
-  return 0;
-}
Index: test/preflow_test.cc
===================================================================
--- test/preflow_test.cc	(revision 924)
+++ test/preflow_test.cc	(revision 923)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -96,9 +96,4 @@
   const PreflowType& const_preflow_test = preflow_test;
 
-  const PreflowType::Elevator& elev = const_preflow_test.elevator();
-  preflow_test.elevator(const_cast<PreflowType::Elevator&>(elev));
-  PreflowType::Tolerance tol = const_preflow_test.tolerance();
-  preflow_test.tolerance(tol);
-
   preflow_test
     .capacityMap(cap)
@@ -119,5 +114,5 @@
   b = const_preflow_test.minCut(n);
   const_preflow_test.minCutMap(cut);
-
+  
   ignore_unused_variable_warning(fm);
 }
Index: test/suurballe_test.cc
===================================================================
--- test/suurballe_test.cc	(revision 877)
+++ test/suurballe_test.cc	(revision 623)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -24,5 +24,4 @@
 #include <lemon/suurballe.h>
 #include <lemon/concepts/digraph.h>
-#include <lemon/concepts/heap.h>
 
 #include "test_tools.h"
@@ -82,12 +81,6 @@
   typedef Digraph::Arc Arc;
   typedef concepts::ReadMap<Arc, VType> LengthMap;
-
-  typedef Suurballe<Digraph, LengthMap> ST;
-  typedef Suurballe<Digraph, LengthMap>
-    ::SetFlowMap<ST::FlowMap>
-    ::SetPotentialMap<ST::PotentialMap>
-    ::SetPath<SimplePath<Digraph> >
-    ::SetHeap<concepts::Heap<VType, Digraph::NodeMap<int> > >
-    ::Create SuurballeType;
+  
+  typedef Suurballe<Digraph, LengthMap> SuurballeType;
 
   Digraph g;
@@ -109,11 +102,8 @@
   k = suurb_test.run(n, n, k);
   suurb_test.init(n);
-  suurb_test.fullInit(n);
-  suurb_test.start(n);
-  suurb_test.start(n, k);
   k = suurb_test.findFlow(n);
   k = suurb_test.findFlow(n, k);
   suurb_test.findPaths();
-
+  
   int f;
   VType c;
@@ -127,5 +117,5 @@
   k = const_suurb_test.pathNum();
   Path<Digraph> p = const_suurb_test.path(k);
-
+  
   ignore_unused_variable_warning(fm);
   ignore_unused_variable_warning(pm);
@@ -206,9 +196,7 @@
     run();
 
-  // Check run()
+  // Find 2 paths
   {
     Suurballe<ListDigraph> suurballe(digraph, length);
-
-    // Find 2 paths
     check(suurballe.run(s, t) == 2, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 2),
@@ -220,6 +208,9 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-
-    // Find 3 paths
+  }
+
+  // Find 3 paths
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
     check(suurballe.run(s, t, 3) == 3, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
@@ -231,6 +222,9 @@
     for (int i = 0; i < suurballe.pathNum(); ++i)
       check(checkPath(digraph, suurballe.path(i), s, t), "Wrong path");
-
-    // Find 5 paths (only 3 can be found)
+  }
+
+  // Find 5 paths (only 3 can be found)
+  {
+    Suurballe<ListDigraph> suurballe(digraph, length);
     check(suurballe.run(s, t, 5) == 3, "Wrong number of paths");
     check(checkFlow(digraph, suurballe.flowMap(), s, t, 3),
@@ -244,22 +238,4 @@
   }
 
-  // Check fullInit() + start()
-  {
-    Suurballe<ListDigraph> suurballe(digraph, length);
-    suurballe.fullInit(s);
-
-    // Find 2 paths
-    check(suurballe.start(t) == 2, "Wrong number of paths");
-    check(suurballe.totalLength() == 510, "The flow is not optimal");
-
-    // Find 3 paths
-    check(suurballe.start(t, 3) == 3, "Wrong number of paths");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-
-    // Find 5 paths (only 3 can be found)
-    check(suurballe.start(t, 5) == 3, "Wrong number of paths");
-    check(suurballe.totalLength() == 1040, "The flow is not optimal");
-  }
-
   return 0;
 }
Index: test/test_tools.h
===================================================================
--- test/test_tools.h	(revision 877)
+++ test/test_tools.h	(revision 440)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -38,13 +38,9 @@
 ///print something like this (and then exits).
 ///\verbatim file_name.cc:123: error: This is obviously false. \endverbatim
-#define check(rc, msg)                                                  \
-  {                                                                     \
-    if(!(rc)) {                                                         \
-      std::cerr << __FILE__ ":" << __LINE__ << ": error: "              \
-                << msg << std::endl;                                    \
-      abort();                                                          \
-    } else { }                                                          \
-  }                                                                     \
-
+#define check(rc, msg) \
+  if(!(rc)) { \
+    std::cerr << __FILE__ ":" << __LINE__ << ": error: " << msg << std::endl; \
+    abort(); \
+  } else { } \
 
 #endif
Index: tools/Makefile.am
===================================================================
--- tools/Makefile.am	(revision 674)
+++ tools/Makefile.am	(revision 674)
@@ -0,0 +1,17 @@
+EXTRA_DIST += \
+	tools/CMakeLists.txt
+
+if WANT_TOOLS
+
+bin_PROGRAMS += \
+	tools/dimacs-solver \
+	tools/dimacs-to-lgf \
+	tools/lgf-gen
+
+dist_bin_SCRIPTS += tools/lemon-0.x-to-1.x.sh
+
+endif WANT_TOOLS
+
+tools_dimacs_solver_SOURCES = tools/dimacs-solver.cc
+tools_dimacs_to_lgf_SOURCES = tools/dimacs-to-lgf.cc
+tools_lgf_gen_SOURCES = tools/lgf-gen.cc
Index: tools/dimacs-solver.cc
===================================================================
--- tools/dimacs-solver.cc	(revision 877)
+++ tools/dimacs-solver.cc	(revision 644)
@@ -3,5 +3,5 @@
  * This file is a part of LEMON, a generic C++ optimization library.
  *
- * Copyright (C) 2003-2010
+ * Copyright (C) 2003-2009
  * Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
  * (Egervary Research Group on Combinatorial Optimization, EGRES).
@@ -89,8 +89,8 @@
   pre.run();
   if(report) std::cerr << "Run Preflow: " << ti << '\n';
-  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';
-}
-
-template<class Value, class LargeValue>
+  if(report) std::cerr << "\nMax flow value: " << pre.flowValue() << '\n';  
+}
+
+template<class Value>
 void solve_min(ArgParser &ap, std::istream &is, std::ostream &,
                Value infty, DimacsDescriptor &desc)
@@ -128,6 +128,5 @@
     std::cerr << "Run NetworkSimplex: " << ti << "\n\n";
     std::cerr << "Feasible flow: " << (res ? "found" : "not found") << '\n';
-    if (res) std::cerr << "Min flow cost: "
-                       << ns.template totalCost<LargeValue>() << '\n';
+    if (res) std::cerr << "Min flow cost: " << ns.totalCost() << '\n';
   }
 }
@@ -149,9 +148,9 @@
   if(report) std::cerr << "Run MaxMatching: " << ti << '\n';
   if(report) std::cerr << "\nCardinality of max matching: "
-                       << mat.matchingSize() << '\n';
-}
-
-
-template<class Value, class LargeValue>
+                       << mat.matchingSize() << '\n';  
+}
+
+
+template<class Value>
 void solve(ArgParser &ap, std::istream &is, std::ostream &os,
            DimacsDescriptor &desc)
@@ -167,9 +166,9 @@
       exit(1);
     }
-
+  
   switch(desc.type)
     {
     case DimacsDescriptor::MIN:
-      solve_min<Value, LargeValue>(ap,is,os,infty,desc);
+      solve_min<Value>(ap,is,os,infty,desc);
       break;
     case DimacsDescriptor::MAX:
@@ -239,5 +238,5 @@
 
   DimacsDescriptor desc = dimacsType(is);
-
+  
   if(!ap.given("q"))
     {
@@ -264,16 +263,14 @@
       std::cout << "\n\n";
     }
-
+    
   if(ap.given("double"))
-    solve<double, double>(ap,is,os,desc);
+    solve<double>(ap,is,os,desc);
   else if(ap.given("ldouble"))
-    solve<long double, long double>(ap,is,os,desc);
+    solve<long double>(ap,is,os,desc);
 #ifdef LEMON_HAVE_LONG_LONG
   else if(ap.given("long"))
-    solve<long long, long long>(ap,is,os,desc);
-  else solve<int, long long>(ap,is,os,desc);
-#else
-  else solve<int, long>(ap,is,os,desc);
+    solve<long long>(ap,is,os,desc);
 #endif
+  else solve<int>(ap,is,os,desc);
 
   return 0;
Index: tools/lemon-0.x-to-1.x.sh
===================================================================
--- tools/lemon-0.x-to-1.x.sh	(revision 691)
+++ tools/lemon-0.x-to-1.x.sh	(revision 574)
@@ -36,8 +36,8 @@
         -e "s/Edge\>/_Ar_c_label_/g"\
         -e "s/\<edge\>/_ar_c_label_/g"\
-        -e "s/_edge\>/__ar_c_label_/g"\
+        -e "s/_edge\>/_ar_c_label_/g"\
         -e "s/Edges\>/_Ar_c_label_s/g"\
         -e "s/\<edges\>/_ar_c_label_s/g"\
-        -e "s/_edges\>/__ar_c_label_s/g"\
+        -e "s/_edges\>/_ar_c_label_s/g"\
         -e "s/\([Ee]\)dge\([a-z]\)/_\1d_ge_label_\2/g"\
         -e "s/\([a-z]\)edge/\1_ed_ge_label_/g"\
@@ -69,9 +69,4 @@
         -e "s/_GR_APH_TY_PEDE_FS_label_/GRAPH_TYPEDEFS/g"\
         -e "s/_DIGR_APH_TY_PEDE_FS_label_/DIGRAPH_TYPEDEFS/g"\
-        -e "s/\<digraph_adaptor\.h\>/adaptors.h/g"\
-        -e "s/\<digraph_utils\.h\>/core.h/g"\
-        -e "s/\<digraph_reader\.h\>/lgf_reader.h/g"\
-        -e "s/\<digraph_writer\.h\>/lgf_writer.h/g"\
-        -e "s/\<topology\.h\>/connectivity.h/g"\
         -e "s/DigraphToEps/GraphToEps/g"\
         -e "s/digraphToEps/graphToEps/g"\
